UNIVERSITE LIBANAISE FACULTE DE GENIE BRANCHE 1

UNIVERSITE LIBANAISE FACULTE DE GENIE BRANCHE 1 IMPLEMENTATION PARALLELE D UN ALGORITHME DE TRAITEMENT D IMAGE SUR FPGA EN UTILISANT LABVIEW Rapport de Projet de Fin d Etude, Génie Electrique Electronique, Option Contrôle et Informatique Industrielle. Réalisé par Mahmoud ZAKARIA Sous la direction de Dr. Rafic AYOUBI Dr. Wassim FALOU Effectué, de Mars à Juillet 2012, Au Laboratoire de l'université Libanaise Soutenu devant Dr. Mohamad KHALIL Dr. Clovis FRANCIS Dr. Haissam ZIADE

Remerciements Tout d abord j aimerai remercier chaleureusement les responsables de mon projet : Dr. RAFIC AYOUBI et Dr. WASSIM FALOU pour leurs aides, et leurs suggestions qui ont eu un rôle important dans l élaboration de ce travail. J aimerai remercier Dr. MOHAMAD KHALIL, Dr. CLOVIS FRANCIS et Dr. HAISSAM ZIADE d avoir d accepté d être membre de mon jury et de m avoir encouragé et assisté tout au long du projet. J aimerai remercier Dr. CLOVIS FRANCIS pour son effort, pour ses conseils intéressants tout au long de ces cinq ans d études. Je tiens à remercier mes amies Zakaria, Rami,Obada, Ahmad, Dany, Saïd, Hassan, Baher, Moumtaz qui se sont trouvés toujours disponible et pour assurer une ambiance de joie parmi la classe. Je voudrais également remercier mes parents d avoir m assuré un environnement adéquat pour la bonne continuité de mes études. Mahmoud ZAKARIA

Résumé Les circuits FPGAs sont largement utilisés aujourd hui pour effectuer divers traitements en temps réel. L arrivée des FPGAs a permis de réduire le nombre de portes logiques nécessaires pour réaliser une application formée d une chaîne d algorithmes de traitement d image. Nous présentons dans ce projet une application de traitement d image, le filtrage d images par un filtre de moyennage, qui réalise une moyenne pondérée des valeurs dans le voisinage, avec un poids fort au centre du voisinage et faible à la périphérie. Avec un FPGA, on passe du traitement logiciel (software) qui est très lent au traitement matériel (hardware) qui est très rapide. L application effectuée a permis de montrer la rapidité d un tel traitement d une part et la rapidité et la simplicité de l algorithme proposé d autre part. Dans ce travail on propose aussi un algorithme simple qui est supporté avec un tel dispositif. Mots clés : Filtre de moyennage, QUARTUS, VHDL, FPGA, Carte PCI 7830, Traitement d images.

Abstract FPGA component are largely used today to perform various algorithms, digital filtering, in real time. The emergence of the FPGAs permits to reduce the number of the necessary resources to achieve an image processing application, tasks chain. We present this as an application of image processing, filtering of images by a Gaussian filter, which performs a weighted average of the values in the neighborhood, with a strong weight in the center of the neighborhood and low at the periphery. With FPGAs, we pass from software processing which is very slow to hardware processing which is very fast, so we calculate the time of hardware processing that shows the speed of this processing on the one hand and the speed and simplicity of our proposed algorithm on the other. Still, we do not forget the capacity of our algorithm so we propose a simple algorithm that is supported with such a device. Keywords: Averaging filter, QUARTUS, VHDL, FPGA, PCI7830,Image Processing.

Table des matières INTRODUCTION GENERALE ET CAHIER DE CHARGES...3 CHAPITRE I : EXEMPLES D IMPLEMENTATION MATERIELLE DES ALGORITHMES DU TRAITEMET D IMAGE SUR FPGA I.1. Introduction...... 5 I.2. Rank Order Filter... 5 I.2.1. Définition.....5 I.2.2. Algorithme...6 I.2.3. Implémentation en utilisant MATLAB......6 I.2.4. Implémentation en utilisant VHDL............7 I.2.5. Comparaison entre les algorithmes VHDL et MATLAB.. 10 I.3. Détection de contours...... 12 I.3.1. Définition......12 I.3.2 L opérateurdesobel........ 13 I.3.3. Implémentation matérielle en utilisant un FPGA.....14 I.3.4. Résultats expérimentaux......16 I.4. Conclusion....... 18 CHAPITRE II : DESCRIPTION DE L ALGORITHME D AMELIORATION D IMAGE PAR UN FILTRE DE MOYENNAGE II.1. Introduction 19 II.2. Amélioration d image par un filtre de moyennage 19 II.2.1. Définition.19 II.2.2. Description...19 II.2.3. Avantages et inconvenients.. 20 II.2.4. Solution 20 II.2.5. Coût de cet algorithme.22 II.2.6. Comparaison entre les deux methodes.22 II.3. Exemple avec un masque bien déterminé..23 II.3.1. Description...23 II.3.2. Temps...25 II.3.3. Coût de point de vue hardware 25 II.4. Conclusion.26 CHAPITRE III : IMPLEMENTATION MATERIELLE EN UTILISANT LE LANGAGE VHDL III.1. Introduction...27 III.1.1. Le logiciel Quartus..27 III.1.2. Le simulateur ModelSim.27 III.2. Description générale.28 III.3. Description matérielle d un pixel..28 III.3.1. Description externe. 28 III.3.2. Description interne..30 Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 1

III.3.3. Simulation en utilisant ModelSim..30 III.4. Description matérielle da la machine d état..31 III.4.1. Description externe.31 III.4.2. Description interne..32 III.5. Description matérielle de toute l image 33 III.5.1. Connections entre les pixels 33 III.5.2. Connections entre les pixels et la machine d état...33 III.5.3. Simulation en utilisant ModelSim..34 III.6. Compilation sur Quartus...35 III.6.1. Temps et horloge.36 III.6.2. Mémoire..36 III.6.3. Limite du taille de l image.. 37 III.6.4. Courbes de l horloge et du mémoire en fonction de nombre de pixels..37 III.7. Conclusion 38 CHAPITRE IV : IMPLEMENTATION SUR LA CARTE PCI 7830 EN UTILISANT LABVIEW FPGA ET RESULTATS IV.1. Introduction...39 IV.2. Utilité du FPGA 39 IV.3. LabView et LabView FPGA...40 IV.4. La carte PCI 7830.40 IV.5. Traitement de notre algorithme 41 IV.5.1. Introduction.41 IV.5.2. Description du HOST VI et FPGA VI 42 IV.6. Résultats 45 CONCLUSION GENERALE ET PERSPECTIVES...46 REFERENCES.48 ANNEXES ANNEXE A : MATLAB M-FILES...49 ANNEXE B : VHDL SOURCE FILES...50 ANNEXE C : Simulation using ModelSim...82 ANNEXE D : Diagrammes...87 ANNEXE E : Moving Examples to another FPGA Target...88 ANNEXE F: Importing External IP Into LabVIEW FPGA...98 Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 2

Introduction générale et cahier de charges Les concepteurs d applications de traitement du signal sont souvent forcés de choisir entre flexibilité et performance à cause des solutions limitées disponibles. Les processeurs DSP sont peu coûteux, flexibles et peuvent être utilisés dans de nombreuses applications. Toutefois, ces processeurs ne peuvent délivrer qu une puissance de calcul limitée en temps réel à cause du séquencement à travers le goulot d étranglement de l accumulateur - multiplieur. Les circuits programmables fournissent une puissance de calcul importante en maintenant la complète flexibilité d un processeur DSP. Des algorithmes traditionnellement considérés comme une séquence d instructions peuvent être analysés pour déterminer un parallélisme possible. Implémenter des algorithmes au niveau matériel permet un parallélisme au niveau calcul, ce qui conduit à des performances supérieures par rapport à des processeurs DSP. L échelle d une fonction peut être augmentée avec une dégradation minime des performances. Au contraire, le traitement séquentiel des processeurs DSP conduit à une dégradation des performances proportionnelle à l augmentation du nombre de traitements. L amélioration des performances des circuits programmables résulte de l augmentation de la fréquence d horloge et du nombre de cellules logiques du circuit. De plus, la description d une architecture optimisée en code synthétisable VHDL avec une approche hiérarchique et modulaire apporte une bonne flexibilité au système. Le FPGA est le circuit logique programmable le plus couramment utilisé de nos jours, de part ses capacités, sa vitesse et sa grande flexibilité. Ces architectures mixent généralement des composants matériels et logiciels travaillant en concurrence afin de répondre le plus efficacement à la contrainte temporelle imposée. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 3

Donc dans notre projet on propose de faire l implémentation matérielle d un algorithme de traitement d image et plus spécialement le filtrage d une image avec un filtre de moyennage. La méthode classique ou logicielle consiste à faire varier les valeurs des pixels séquentiellement d où on a besoin de long temps pour finir les traitements. C est pour cela on passe à la méthode matérielle qui offre un parallélisme permettant de répondre à la contrainte temporelle. D autre part, si on va agrandir la taille de l image on a besoin d une mémoire très grande. C est pour cela nous proposons un algorithme simple qui n a pas besoin d une grande mémoire et ne contient pas une logique très compliquée. Dans un premier temps on écrit notre algorithme en langage VHDL et on fait sa compilation en utilisant le logiciel de simulation d Altera QUARTUS pour vérifier que notre algorithme a besoin d une horloge très rapide et notre design est supporté par une telle mémoire. Puis on utilise LabView FPGA pour simuler notre design sur la carte PCI 7830 et on utilise LabView pour faire l interfaçage avec l extérieur et notre design. Pour aboutir au but de notre projet nous allons l organiser de la façon suivante : Dans le chapitre 1, on va présenter un article en relation avec notre projet qui fait l implémentation de deux algorithmes de traitements d images (détection de contours et segmentation d une image) dans un FPGA. Dans le chapitre 2, on va expliquer notre algorithme. On va décrire notre algorithme en langage VHDL et montrer sa compilation en utilisant le logiciel QUARTUS dans le chapitre 3.On finit par montrer nos simulations faites sur la carte PCI 7830 en utilisant le logiciel LabView et la présentation des résultats au chapitre 4. Enfin une conclusion clôturera l ensemble. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 4

Chapitre I : Exemples d implémentation matérielle des algorithmes de traitement d image sur FPGA I.1. Introduction Dans ce chapitre, on va présenter l implémentation logicielle et matérielle de 2 algorithmes de traitement d image, le premier est le «Rank Order Filter», et le deuxieme est la détection des contours. A la fin de ce chapitre, on va montrer l intérêt et l utilité de l implémentation matérielle sur l implémentation logicielle, pour vérifier que la première implémentation est très rapide. Le premier algorithme est une thèse qui est faite par : «Anthony Edward Nelson» soumis au «Faculty of the Graduate School of Vanderbilt University» pour obtenir le mastère de science dans le génie électrique en 2000 [1]. Le deuxième algorithme est un article qui est fait par : «Ms. PRIYANKA S. CHIKKALI» et «Prof. K. PRABHUSHETT» et publié dans le journal «IJAEST» en 2011 [2]. I.2. Rank Order Filter I.2.1. Définition Le filtre «Rank Order Filter» [3] est un algorithme particulièrement fréquent dans les systèmes de traitement d'image. C est un filtre non linéaire. Il offre plusieurs effets utiles, telles que le lissage et la suppression du bruit. Le filtre médiane [3], qui est un filtre «Rank Order Filter», est particulièrement utile dans la suppression du bruit. I.2.2. Algorithme On va traiter le filtre médiane : pour chaque pixel dans une image, la fenêtre de pixels voisins est trouvée. Ensuite, les valeurs de pixels sont triées par ordre croissant. D où le pixel à l entrée est remplacé par la valeur médiane. La figure I.1 montre un exemple de cet algorithme pour un filtre médiane d ordre 5 (nombre des pixels dans la fenêtre). Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 5

Figure I.1. Représentation graphique de fonctionnement de filtre «Rank Order Filter» I.2.3 Implémentation en utilisant MATLAB Le logiciel MATLAB a été utilisé pour développer une première version de filtre «Rank Order Filter». Ensuite les résultats pourraient être comparés avec la version matérielle. L implémentation en MATLAB de filtre «Rank Order Filter» est nommée «ro_filt.m» et se trouve dans l annexe A. Il fonctionne en utilisant des boucles pour simuler une fenêtre glissante de voisinages de pixels. Pour chaque mouvement de la fenêtre, l'algorithme crée une liste des valeurs de pixel dans l'ordre croissant. De cette liste, l'algorithme prend un pixel spécifique. La sortie du programme est une image comprenant des pixels de sortie de l'algorithme. La figure I.2 montre quelques images de sortie pour une image d'entrée donnée en utilisant «ro_filt.m». Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 6

Figure I.2. Exemple des images obtenues en utilisant «ro_filt.m» I.2.4. Implémentation en utilisant VHDL Pour implémenter cet algorithme on a besoin de 3 entités VHDL : «window_3x3.vhd», «sort_3x3.vhd» et «rc_counter.vhd» (voir Annexe B). Ensuite, on a besoin d une seule entité «ro_filt_3x3.vhd» pour faire le groupement de ces 3 entités précédentes et pour assurer le bon fonctionnement de l algorithme. 1- Génération de la fenêtre de glissage: «window_3x3.vhd» (voir Annexe B) La figure I.3 montre une représentation graphique de l'architecture FIFO et bascule utilisé pour cette conception pour une fenêtre de pixel de sortie donnée. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 7

Figure I.3. Architecture du générateur de fenêtre 2- Implémentation de triage: «sort_3x3.vhd» (voir Annexe B) Cette implémentation utilise la génération de la fenêtre de glissage («window_3x3.vhd»). L implémentation de triage est trouvée dans la figure I.4 qui consiste à trier par ordre croissant les 9 valeurs de la fenêtre de pixels. Cette implémentation utilise des registres et des comparateurs pour le triage de 9 valeurs de fenêtre glissante de voisinages. Chaque rxx est un registre et chaque cxx est un comparateur. Ce design est tout simplement accompli en VHDL en utilisant «if/else statment» : if wx1 < wx2 then cx1_l <= wx1; cx1_h <= wx2; else cx1_l <= wx2; cx1_h <= wx1; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 8

Figure I.4. Implémentation hardware du triage 3- Implémentation de compteur : Un compteur VHDL a été écrit pour compter le mouvement de pixel ainsi que les flux de données dans l'entité. L entité VHDL qui implémente cette fonctionnalité est appelée «rc_counter.vhd» et se trouve dans l'annexe B. Pour que le filtre «Rank Order Filter» fonctionne correctement, ces trois entités VHDL doit être instancié dans l'algorithme lui-même. Cette fonctionnalité est faite par «component statements and port maps» en utilisant VHDL. La figure I.5 montre la structure de conception VHDL utilisé pour cet algorithme. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 9

Figure I.5. Structure d un algorithme VHDL I.2.5. Comparaison entre les algorithmes VHDL et MATLAB Les figures I.6 et I.7 montrent des comparaisons entre les algorithmes VHDL et MATLAB pour deux ordres. Ensuite on trouve «Error Plot» et «Error Mesh Plot», qui montrent une vue en trois dimensions de l'erreur. Dans ces cas, il est évident que les deux algorithmes sont identiques. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 10

Figure I.6. Comparaison entre les algorithmes VHDL et MATLAB de «ro_filter_3x3» avec ordre= 4 Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 11

Figure I.7. Comparaison entre les algorithmes VHDL et MATLAB de «ro_filt_3x3»avec ordre= 8 I.3. Détection de contours I.3.1. Définition La détection de contours [3] est une méthode de détermination des discontinuités dans les images niveaux de gris. Les contours sont un des éléments les plus importants dans l'analyse d'image et de la transformation en vision par ordinateur, car ils jouent un rôle non négligeable dans de nombreuses applications de traitement de l'image notamment pour la vision industrielle. Toutefois, aucun algorithme de détection de contours peut découvrir avec succès les contours des images diverses et aucune mesure quantitative spécifique de la qualité pour la détection de contours est donnée à l'heure actuelle. Les mécanismes classiques de détection des contours consistent à mesurer les changements des pixels en les comparant avec leurs voisins. Cela se fait souvent par la détection de la valeur maximale du gradient comme: Roberts, Prewitt, Sobel, Canny et ainsi de suite qui sont tous des détecteurs de contours classiques. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 12

I.3.2. L opérateur de Sobel L'opérateur de Sobel [3] est le premier opérateur classique de détection de contours en calculant l approximation du gradient de la fonction d'intensité d'image. À chaque point dans l'image, le résultat de l'opérateur de Sobel est la norme correspondante de ce vecteur gradient. L'opérateur de Sobel ne considère que les deux orientations 0 et 90 qui sont les noyaux de convolution comme indique la Figure I.8. Figure I.8. Noyaux de convolution dans les directions X et Y Ces noyaux peuvent ensuite être combinés ensemble pour trouver la valeur absolue du gradient en chaque point. L'amplitude du gradient est donnée par: Typiquement une amplitude approximative est calculée en utilisant: C'est beaucoup plus rapide à calculer. L'opérateur Sobel a l'avantage de la simplicité dans le calcul. Mais la précision est relativement faible, car on n utilise que deux noyaux de convolution pour détecter le bord de l'image. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 13

I.3.3. Implémentation matérielle en utilisant un FPGA Cette conception utilise des noyaux de convolution 3 3 qui traite une image 256 256 niveaux de gris de la base de données de l ordinateur personnel. L'architecture est représentée dans la figure I.9. Le système est divisé en quatre modules: Module de génération de pixel 3 3 (3 3 pixel generation), module de l amélioration de l opérateur de Sobel (Sobel Enhancement), module de contrôle des contours (edges control) et segmentation binaire (binary segmentation). Dans ce système, «Clk» est le signal d'horloge, «Reset» est le signal de réinitialisation et «EN» est un signal de contrôle de données, «Data input» est le signal de pixel de l'image niveaux de gris, «Result» est le résultat de signal d'opérateur de détection des contours, «Generation data» et «Data» sont les signaux centraux. Figure I.9. Architecture La structure du module «3 3 pixel generation» est représentée dans la Figure I.10. Ce module comprend 3 shift register et 2 FIFOs. La FIFO est utilisée pour stocker une ligne de données d'image. Les données d'image sont entrés en fonction du signal d'horloge donc P1, P2,, P9 est les données d'image 3*3 temporaires. Lorsque les données sont entrés en permanence, P1, P2,, P9 change leurs valeurs. Il peut contenir tous les pixels d'une image. La FIFO est générée à partir d une RAM à double accès. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 14

Figure I.10. Module de génération de pixel 3 3 (3 3 pixel generation) Dans le module «Sobel Enhancement» le noyau de convolution d'orientation utilise la construction de traitement parallèle. Le résultat de convolution d'orientation dans la direction X est comparé avec l'autre direction Y et ensuite la valeur maximale est à la sortie. La structure pipeline est utilisée pour calculer chaque noyau de convolution d'orientation dans les deux directions. Il est six données d'entrées correspondantes parce que trois coefficients de chaque noyau de convolution sont à zéro multiplié par 2. La structure est représentée dans la Figure I.11. Figure I.11. Structure de convolution La structure du module du contrôle des contours (edges control) est représentée dans la figure I.12. «Clk» est le signal d'horloge et «Reset» est le signal de réinitialisation. «Turn» est le signal de validation, lorsque «Turn» est valide le module fonctionne. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 15

«EN» est le signal de commande de sortie de données. Ce module peut savoir la position du pixel en cours et si ce pixel appartient au contour de l'image. Figure I.12. Module de contrôle de contours (Edges Control Module) La structure de module de segmentation binaire est représentée dans la Figure I.13. «EN» est le signal de commande de sortie de données. Data est le résultat de «Sobel enhancement operator module». Result est 0 ou 255. Dans ce module le résultat final est l'image binaire de détection de contours n'ayant que deux valeurs de pixels en fonction de la valeur de seuil donnée soit 0 et 255. Figure I.13. Segmentation binaire (Binary segmentation) I.3.5. Résultats expérimentaux Les résultats expérimentaux de détection de contours de l'image dans MATLAB et sa comparaison en VHDL sont présentés ci-dessous : Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 16

Figure I.14. L image originale pour la détection de contour Figure I.15. Le gradient dans la direction X pour la détection de contours dans MATLAB Figure I.16. Le gradient dans la direction Y pour la détection de contours dans MATLAB Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 17

Figure I.17. Le résultat détection de contours dans MATLAB. I.4. Conclusion Figure I.18. Le résultat de détection de contours en utilisant VHDL On vérifie la rapidité et l efficacité de l implémentation matérielle en utilisant VHDL, c est pour cela il faut tester ces propriétés par l implémentation d un autre algorithme de traitement d image. Dans le chapitre 2, on va faire la description de cet algorithme qui est le filtrage d une image par un filtre de moyennage en utilisant un masque 3*3. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 18

Chapitre II : Description de l algorithme d amélioration d image par un filtre de moyennage II.1. Introduction Dans ce chapitre, on va faire la description générale de l algorithme de filtrage par un filtre de moyennage général. Puis on spécifie notre algorithme avec un masque bien déterminé pour la phase de l implémentation. Ensuite, on va présenter la différence entre l implémentation logicielle et matérielle du point de vue capacité et temps. II.2. Amélioration d une image par un filtre de moyennage II.2.1. Définition Un filtre de moyennage consiste à éliminer les bruits qui existent dans une image pour améliorer. Les masques qui sont utilisés par ce filtre peuvent être de taille 3*3, 5*5, 11* 11, 43*43,. Mais dans notre travail, on utilise seulement un masque de taille 3*3. Notons que la valeur du centre du masque est grande mais les voisinages ont des valeurs descendantes plus on s éloigne du centre. II.2.2. Description On a une image (n*n) pixels : ( ) Avec chaque pixel sur 12 bits. On va filtrer cette image avec un filtre (masque) tel que : ( ) Il faut varier les valeurs de tous les pixels en commençant par le pixel (1,1) jusqu'à (n,n). On prend un pixel quelconque, Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 19

Il faut que la nouvelle valeur de devient : On fait cette procédure sur tous les pixels. II.2.3. Avantages et inconvénients Si on va implémenter notre système avec cette méthode, on obtient un hardware très petit mais le temps d exécution est assez grand. - On a besoin d un seul additionneur (12 bits avec 12 bits), d un seul multiplieur et d un seul diviseur. - Il faut qu on a 2 matrices chaque matrice de taille n*n, la première matrice pour mémoriser les valeurs initiales des pixels avant l application de l algorithme et la deuxième pour mémoriser les nouveaux résultats après l application de l algorithme. - On a besoin de mémoriser le masque une seule fois donc matrice de taille (3*3). En plus, on a le facteur temps qui est très important : Avec cette méthode on a besoin de temps assez grand pour passer à travers toute l image car dans chaque pixel on a un hardware très compliqué et grand, ce qui rend le système très lent. De plus l implémentation se fait par logiciel ce qui conduit à un système assez lent. Donc notre but est de faire l implémentation d un algorithme qui traite ces problèmes et passe à travers toute l image avec un temps assez petit. C est pour cela on doit faire une implémentation matérielle qui assure le parallélisme donc le traitement de tous les pixels d une image se fait en parallèle et en même temps. II.2.4. Solution Pour débarrasser de ces problèmes, on va implémenter la méthode suivante : Au lieu de faire varier les valeurs des pixels successivement du premier pixel jusqu'au dernier pixel, on décompose le travail dans chaque pixel en 8 étapes mais la variation des valeurs des pixels dans chaque étape se fait en parallèle et en même temps. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 20

On prend la matrice initiale : ( ) Première étape : On prend le pixel et on l additionne avec le pixel qui est en gauche et on fait la même procédure sur tous les pixels (en même temps) : = Deuxième étape : On fait la même procédure qu en première étape mais on additionne le pixel pixel qui est en gauche-haut : avec le Troisième étape : La même procédure qu en deuxième étape mais on additionne le pixel qui est en haut : avec le pixel Quatrième étape : La même procédure qu en 3ème étape mais on additionne le pixel est en haut-droit : avec le pixel qui Cinquième étape : La même procédure qu en 4ème étape mais on additionne le pixel est à droite : avec le pixel qui Sixième étape : La même procédure qu en 5ème étape mais on additionne le pixel est en droit-bas : avec le pixel qui Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 21

Septième étape : La même procédure qu en 6ème étape mais on additionne le pixel est en bas : Huitième étape : La même procédure qu en 7ème étape mais on additionne le pixel est en bas-gauche : avec le pixel qui + avec le pixel qui II.2.5. Coût de cet algorithme Si on a (n*n) pixels et si chaque pixel est de 12 bits. Méthode séquentielle : Dans chaque pixel on a besoin de 9 additions, 9 multiplications et 1 division qui sont répétés de n*n fois pour l image en entière. Donc: on a besoin de (9+9+1)*(n*n) étapes. Remarquons que cette valeur dépend du taille de l image. Méthode parallèle : On a besoin de (9+9+1) étapes au lieu (9+9+1)*n*n étapes. Remarquons que cette valeur ne dépend pas du taille de l image. Avec la méthode parallèle, nous gagnons avec le temps. Mais la capacité mémoire est assez grande. En fonction des valeurs du masque utilisées on peut proposer des méthodes qui ont besoin d une mémoire assez petite. On va traiter cette condition dans le paragraphe II.3. II.2.6. comparaison entre les deux méthodes Méthode séquentielle 2 matrices de taille (n*n) chacune, chaque élément est de 12 bits. On a besoin de mémoriser le masque une seule fois donc matrice de taille (3*3). Un seul additionneur. Un seul multiplieur. Un seul diviseur. On a besoin de (9+9+1) *(n*n) étapes pour le traitement total. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 22

Méthode parallèle 2 matrices de taille (n*n) chacune, chaque élément est de 12 bits. Matrice de taille (9*n*n) bytes pour mémoriser le masque dans chaque pixel. (n*n) additionneurs. (n*n) multiplieurs. (n*n) diviseurs. On a besoin de (9+9+1) étapes pour le traitement total II.3. Exemple avec un masque bien déterminé II.3.1. Description Dans notre projet on va faire l implémentation avec le masque suivant : ( ) Notons que ce masque est un filtre de moyennage qui fait l amélioration de l image. Avec ce filtre le nombre des étapes sont réduites à 4 étapes : Première étape : On prend la matrice initiale : ( ) On prend le pixel et on l additionne avec le pixel qui est en gauche et on fait la même procédure sur tous les pixels : = = + = = + = + = + Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 23

D où la matrice devient : ( ) Deuxième étape : On prend la nouvelle matrice et on fait la même procédure mais on additionne le pixel avec le pixel qui est en haut : = = + + + = + + = + + + D où la matrice devient : ( ) 3ème étape : La même procédure qu en deuxième étape mais on additionne le pixel avec le pixel qui est en bas : = + + = + + + + D où la matrice devient : ( ) Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 24

4ème étape : La même procédure qu en 3ème étape mais on additionne le pixel avec le pixel qui est en droite : = + + + + + D où on obtient le même résultat : II.3.2. Temps Si on a (n*n) pixels et chaque pixel est de 12 bits. On a besoin de 4 étapes pour finir les calculs car les calculs dans tous les pixels se font en parallèle. Dans chaque étape, on a besoin de 12 cycles d additions seulement. Donc on vérifie qu avec ce masque on obtient un temps plus petit que le temps avec un masque quelconque. II.3.3. Coût de point de vue hardware Supposons que chaque pixel est de 12 bits et on a n*n pixels. Mémoire : Pour implémenter notre système, on a besoin de (n*n) registres pour sauvegarder tous les pixels dans une mémoire. Notons qu on n a pas besoin de sauvegarder la matrice de filtrage à cause de l algorithme proposé. Additionneur : Dans notre algorithme, on choisit un additionneur série qui fait l addition de deux bits et le résultat est sauvegardé dans un registre. On choisit un additionneur série pour garantir un petit hardware et qui n est pas très complexe. Notons qu on n a pas besoin de multiplieur à cause de l algorithme proposé qui est un point très fort dans l algorithme. Multiplexeur : Un multiplexeur pour changer la direction de l addition (gauche, droite, haut, bas) et un autre pour changer la direction du transfert de données (direction externe qui assure le Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 25

transfert de données de l extérieur vers les registres, et direction interne qui assure l addition entre les pixels). Machine d état : Pour contrôler l'ensemble de notre système et assurer le séquencement de l algorithme proposé. II.4. Conclusion Après la description de notre algorithme, dans le chapitre suivant, on doit faire la programmation matérielle en langage VHDL de cet algorithme en utilisant le logiciel QUARTUS. Donc on va écrire la programmation matérielle de l image en entier. Puis on va faire la compilation pour s assurer que notre algorithme est supporté par un tel dispositif. Après la compilation, on va calculer le nouveau temps en fonction de l horloge supportée par notre design. Ensuite on va faire la simulation de notre design pour montrer le bon fonctionnement en utilisant le simulateur ModelSim. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 26

Chapitre III : Implémentation matérielle en utilisant VHDL III.1. Introduction Dans ce chapitre on décrit l'implémentation de notre algorithme sur un FPGA en utilisant le langagevhdl et le logiciel QUARTUS. Puis on va faire la compilation pour s assurer que notre design est supporté par l une des familles des dispositifs existent chez Altera. Après compilation, on va calculer le temps en fonction de l horloge de notre design.. Ensuite on va faire la simulation de notre design pour montrer le bon fonctionnement en utilisant le simulateur ModelSim. III.1.1. Le logiciel Quartus Quartus est un logiciel développé par la société Altera, permettant la gestion complète d'un flot de conception CPLD ou FPGA. Ce logiciel permet de faire une saisie graphique ou une description HDL (VHDL ou verilog) d'architecture numérique, d'en réaliser une simulation, une synthèse et une implémentation sur cible reprogrammable. Il comprend une suite de fonctions de conception au niveau système, permettant d accéder à la large bibliothèque d IP d Altera et un moteur de placement-routage intégrant la technologie d optimisation de la synthèse physique et des solutions de vérification. III.1.2. Le simulateur ModelSim Modelsim est un simulateur HDL développé par Mentor Graphics qui supporte plusieurs langages (VHDL, Verilog, SystemVerilog, SystemC). Les produits ModelSim ont une architecture unique utilisant des technologies comme la compilation directe optimisée pour réduire les temps de compilation et de simulation, un kernel unique de simulation et Tcl/Tk comme langage de script pour un plus grand niveau d'ouverture et des mises au point rapides. Exclusives à ModelSim, ces innovations permettent de grandes performances en compilation/simulation, l'entière liberté d'utiliser le VHDL et/ou le Verilog, ainsi qu'une capacité inégalée de personnaliser le simulateur. Enfin les utilisateurs apprécient la facilité d'utilisation et la qualité du support technique. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 27

III.2. Description générale On va implémenter notre algorithme en langage VHDL en utilisant QUARTUS. Notre algorithme comprend 3 fichiers qui sont écrits en VHDL (voir ANNEXE B) : «MyFilterCel.vhdl», «filterdesign_behavioral.vhdl» et «ControlUnit.vhdl». Dans le premier on écrit notre algorithme qui contient l implémentation hardware d un seul pixel. Dans le deuxième on fait l implémentation de l image toute en entière, dans cette phase on utilise le «component» pour assurer la connexion entre un pixel et ses voisins. Dans le troisième on a la machine d état qui contrôle le travail séquentiel de l algorithme. III.3. Description matérielle d un pixel III.3.1. Description externe Chaque pixel est représenté par cette forme dans la figure III.1 ( écrit dans le fichier «MyFilterCel.vhdl»): Figure III.1. Description externe d un pixel Avec : Datain : C est une entrée d un seul bit. Cette entrée permet d entrer les informations bit après bit pour remplir la valeur de ce pixel et les arranger dans son registre. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 28

IWest : C est le bit de poids faible du pixel qui est à gauche du pixel courant. INorth : C est le bit de poids faible du pixel qui est en haut du pixel courant. ISouth : C est le bit de poids faible du pixel qui est en bas du pixel courant. IEast : C est le bit de poids faible du pixel qui est à droite du pixel courant. clk : C est l horloge de notre système. clr : C est une entrée lorsqu elle est mise à 1 la valeur du pixel courant devient zéro. SelDir : C est une entrée de deux bits : Lorsque SelDir = 00, on additionne le bit de poids faible du pixel courant avec le bit de poids faible du pixel qui est à gauche de ce pixel. Lorsque SelDir = 01, on additionne le bit de poids faible du pixel courant avec le bit de poids faible du pixel qui est en haut de ce pixel. Lorsque SelDir = 10, on additionne le bit de poids faible du pixel courant avec le bit de poids faible du pixel qui est en bas de ce pixel. Lorsque SelDir = 11, on additionne le bit de poids faible du pixel courant avec le bit de poids faible du pixel qui est à droite de ce pixel. ShEn : Par cette entrée on fait le décalage à droite de la valeur du pixel. SelIn : C est une entrée d un seul bit : Lorsque SelIn = 1, dans ce cas il faut remplir la valeur du pixel par la valeur initiale avant addition. Lorsque SelIn = 0, la valeur du pixel sera la nouvelle valeur après l addition de la valeur initiale avec l une des valeurs de son voisinage. Dataout : cette sortie est reliée au dernier bit de la valeur du registre existant dans un pixel. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 29

III.3.2. Description interne Chaque pixel est écrit en langage VHDL, d où on obtient le schéma suivant : Figure III.2. Description matérielle d un pixel Donc on a 2 multiplexeurs, 2 registres, un additionneur série (un seul bit) et un registre de décalage. III.3.3. Simulation en utilisant ModelSim (voir ANNEXE C) a- Remplissage du registre à décalage : Supposons qu il faut initialiser par la valeur «000000001111». Pour remplir le registre à décalage il faut que SelIn= 1 et ShEn= 1. Avec ModelSim, on obtient la figure suivante : b- Addition de la valeur du registre avec son voisin qui est à gauche : Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 30

Supposons que le registre est initialisé avec la valeur «000000010000». Supposons que son voisin à gauche est : «000000001111». Pour faire l addition avec la valeur qui est à gauche, il faut que : SelIn= 0, ShEn= 0 et SelDir= 00. D où on obtient la figure suivante : De même on fait l addition avec les autres voisins (droite, haut, bas). Et on peut faire les 4 additions successivement en variant l entrée SelDir. III.4. Description matérielle de la machine d état III.4.1. Description externe Pour assurer le bon fonctionnement de notre système, il faut implémenter une machine d état qui contrôle le travail interne de notre algorithme. D où la machine d état (décrite dans le fichier «ControlUnit.vhdl») : Figure III.3. Description externe de la machine d état Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 31

III.4.2. Fonctionnement interne Dans un premier temps, on est dans l état «0» : Si start= 0 ; donc ShEn= 1 et SelIn= 1 ; dans ce cas les valeurs initiales de tous les pixels sont arrangés bit après bit dans le registre de chaque pixel. On a besoin de 12 cycles pour initialiser tous les valeurs. Si start= 1 ; donc ShEn= 1,SelIn= 0 et SelDir= 00 ; donc on passe à l état «1» ; donc on additionne (bit avec bit) chaque valeur du pixel avec son voisin en gauche. On besoin de 12 cycles pour finir l addition. Après on passe à l etat «2» avec SelDir= 01 pour additionner chaque pixel avec son voisin en haut. De même on a 12 cycles. Puis dans l état «3» avec SelDir= 11 on additionne chaque pixel avec son voisin en bas. De même on a 12 cycles. Avec l etat «4» on a SelDir= 10 ; on additionne chaque pixel avec son voisin à droite. De meme on a besoin de 12 cycles. Et dans l état final «5» on a le résultat final, on a besoin de 12 cycles pour faire apparaitre les 12 bits dans chaque pixel. Figure III.4. Machine d état Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 32

III.5. Description matérielle de toute l image En utilisant le «component» existant dans le langage VHDL on fait toutes les connections entre les pixels eux-mêmes d une part et entre les pixels et la machine d état d autre part. III.5.1. Connections entre les pixels Chaque pixel est connecté avec leurs voisins de la façon suivante : Figure III.5. Connections entre les pixels III.5.2. Connections entre les pixels et la machine d état La machine d état fait la contrôle de 3 entrées «ShEn», «SelIn» et «SelDir» pour assurer la séquencement de notre algorithme : Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 33

Figure III.6. Connections entre les pixels et la machine d état III.5.3. Simulation en utilisant ModelSim Supposons qu on va initialiser tous les pixels avec la valeur «000000000100» et supposons qu on travaille avec16 pixels, on obtient la figure suivante : Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 34

La figure suivante est le complément de la figure précédente : III.6. Compilation sur QUARTUS Après l implémentation sur QUARTUS, on doit faire la compilation pour préciser la valeur maximale de l horloge que notre système peut supporter, pour ensuite calculer le temps total du travail de notre système. De plus, il faut bien préciser si notre algorithme est totalement supporté sur le chip du dispositif (device) utilisé, donc quel est la limite maximale des pixels qu on peut implémenter sur ce dispositif? Après compilation de notre design avec (8*8) pixels, on obtient les 2 rapports suivants : Le premier rapport concerne la mémoire : Ce rapport contient le cout de notre algorithme de point de vue hardware par exemple : Nombre totale des registres utilisés, nombre totale des éléments logiques utilisés, mémoire,. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 35

Le deuxième rapport concerne l horloge : Ce rapport contient la valeur maximale de l horloge qu on peut utiliser. III.6.1. temps et horloge Si on va agrandir le nombre de pixels dans notre implémentation, après chaque compilation des différents designs, QUARTUS a donné une valeur de l horloge pour chaque design qu on peut utiliser pour faire l implémentation. Prenons notre algorithme, avec 60 pixels QUARTUS a fait la compilation sans aucune erreur et donne une horloge de 235.07MHz. On a 6 étapes comme on l a expliqué précédemment et chaque étape a besoin de 12 cycles pour finir son travail. Avec 235.07 MHz et (12*6) cycles; le temps total du travail de notre algorithme est : 12*6*(1/235.07)=0.30629 [μs]. III.6.2. Mémoire Encore, on a dans QUARTUS plusieurs familles des dispositifs (device) et chaque dispositif possède une mémoire spécifique pour implémenter un tel algorithme, donc on ne peut pas agrandir le nombre de pixels comme on veut car la mémoire est limitée. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 36

regitres horloge Après compilation il n y a pas aucune erreur avec 64 pixels, donc on peut implanter notre algorithme dans la mémoire utilisée. Ceci vérifie que notre design n est pas très complexe et assez petit car il contient une logique très simple. III.6.3. Limite du taille de l image On fait la compilation avec (32*32) pixels sans aucune erreur, on obtient une horloge de 173.88 MHz. Avec 64*64 pixels on obtient une horloge de 139.18 MHz. De plus, notre design est supporté par la mémoire ceci vérifie la simplicité de notre algorithme. III.6.4. Courbes de l horloge et du mémoire en fonction de nombre de pixels Commençons par l agrandissement de nombre de pixels, ensuite faisons la compilation et pour chaque étape prenons l horloge correspondante, les registres et la taille du mémoire : 1- Courbe de l horloge en fonction de nombre de pixels: 240 220 200 180 160 140 120 0 500 1000 1500 2000 2500 3000 3500 4000 4500 nombre de pixels 2- Courbe de registres en fonction de nombre de pixels : 4500 4000 3500 3000 2500 2000 1500 1000 500 0 0 500 1000 1500 2000 2500 3000 3500 4000 4500 nombre de pixels Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 37

memoire 3- Courbe du mémoire en fonction de nombre de pixels : 4.5 x 104 4 3.5 3 2.5 2 1.5 1 0.5 0 0 500 1000 1500 2000 2500 3000 3500 4000 4500 nombre de pixels III.7. Conclusion Notre design est compilé sans aucune erreur, donc notre design est supporté avec la petite et l ancienne FPGA chip (Cyclone II) en comparaison avec la fin et la haute famille (stratix family) utilisée cela montre la simplicité de notre algorithme car il contient de logique très simple. Apres implémentation de notre design en utilisant VHDL et le logiciel QUARTUS, il reste d implémenter sur un FPGA en utilisant LabView FPGA. Et il faut montrer qu on peut faire l implémentation de notre design dans la mémoire du FPGA. Tout ça on va le traiter dans le chapitre 4. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 38

Chapitre IV : Implémentation sur la carte PCI 7830 en utilisant LabView FPGA et résultats IV.1. Introduction Dans ce chapitre, on va faire l implémentation de notre design avec (8*8) pixels sur FPGA en utilisant LabView FPGA. On utilise pour cette implémentation la carte PCI 7830 qui contient une horloge de 40 MHz. Ainsi, on va montrer que notre design est supporté avec ce FPGA. IV.2. Utilité du FPGA Les FPGA (Field-Programmable Gate Array) sont des circuits intégrés reprogrammables. Ross Freeman, le co-fondateur de la société Xilinx, a inventé le premier FPGA en 1985. Si les FPGA rencontrent un tel succès dans tous les secteurs, c'est parce qu'ils combinent les meilleures caractéristiques des ASIC (Application-Specific Integrated Circuits) et des systèmes basés processeur. Ils offrent un cadencement par matériel qui leur assure vitesse et fiabilité, mais ils sont plus rentables que les ASIC personnalisés. Les circuits reprogrammables jouissent également de la même souplesse d'exécution logicielle qu'un système basé processeur, mais ils ne sont pas limités par le nombre de cœurs de traitement disponibles. Contrairement aux processeurs, les FPGA sont vraiment parallèles par nature, de sorte que plusieurs opérations de traitement différentes ne se trouvent pas en concurrence lors de l'utilisation des ressources. Chaque tâche de traitement indépendante est affectée à une section spécifique du circuit, et peut donc s'exécuter en toute autonomie sans dépendre aucunement des autres blocs logiques. En conséquence, vous pouvez accroître le volume de traitement effectué sans que les performances d'une partie de l'application n'en soient affectées pour autant. On utilise un FPGA dans notre projet pour profiter la haute vitesse de calcul assuré par l horloge du FPGA et pour profiter du calcul complexe assuré par les circuits programmables. D autre part et du fait de la reprogrammation d un FPGA, on peut implémenter plusieurs algorithmes. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 39

IV.3. LabView et LabView FPGA LabView (Laboratory Virtual Instrument Engineering Workbench) est un langage de programmation dédié au contrôle d instruments et l analyse de données. Contrairement à la nature séquentielle des langages textuels, LabView est basé sur un environnement de programmation graphique utilisant la notion de flot de données pour ordonnancer les opérations. LabView intègre l acquisition, l analyse, le traitement et la présentation de données. On utilise LabView dans notre projet pour faire l interfaçage entre notre design et l extérieur. LabView FPGA est le module de programmation des "réseaux logiques programmables". Ces circuits sont implantés sur divers types de matériels de chez NI, ils proviennent du fondeur Xilinxs. Ils font partie de la gamme Startan économique ou Virtex haute performance. IV.4. La carte PCI 7830 Figure IV.1. La carte PCI 7830 [4] - 4 entrées analogiques, avec taux d'échantillonnage indépendants jusqu'à 200kHz, résolution de 16 bits, ± 10 V. - 4 sorties analogiques, les taux de mise à jour indépendants jusqu'à1 MHz, résolution de 16 bits, ± 10 V. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 40

- 56 lignes numériques configurables comme entrées, sorties, compteurs, ou logique personnalisée à des taux allant jusqu'à 40MHz. - Virtex-II 1M gate FPGA programmable with the LabVIEW FPGA Module. - Connectivité au NI9151pour l'expansion d'e / S et de conditionnement du signal à faible coût. La carte NI PCI-7830R multifonction RIO dispose d'une puce FPGA programmable par l'utilisateur pour le traitement embarqué et l opération flexible d E / S. Vous pouvez configurer toutes les fonctionnalités analogiques et numériques en utilisant NI LabVIEW diagrammes graphiques et le Module LabVIEW FPGA. IV.5. Traitement de notre algorithme IV.5.1. Introduction On a écrit notre algorithme en VHDL, il reste de l exécuter en utilisant LabView FPGA par l «importation d'ip externe dans LabVIEW FPGA avec le nœud CLIP». De plus, on va faire quelque interfaçage avec LabView afin de faciliter l acquisition des données. Ensuite on va l exécuter sur la carte PCI 7830, donc on utilise FPGA pour profiter de l horloge 40 MHz (qui est assez rapide), la grande mémoire et la reprogrammation de la carte. Pour implémenter notre algorithme on a besoin de deux VI, HOST VI et FPGA VI (voir ANNEXE D). Dans HOST VI on prend les valeurs des pixels et on les sauvegarde dans un FIFO (FIFOHT). Une fois les valeurs sont dans le FIFO, FPGA VI s exécute en commençant par la lecture du FIFO, l exécution et le traitement de notre algorithme, puis les nouvelles valeurs des pixels sont sauvegardées dans un autre FIFO (FIFOTH). A la fin, HOST VI prend les nouvelles valeurs du FIFO et les affiche. Notons qu on prend 64 pixels et on fait le traitement car on ne peut pas agrandir le nombre de pixels car dans cette carte la mémoire est limitée. L horloge est de 40 MHz mais notre design peut fonctionner avec une horloge de 235.07 MHz!! Donc il y a perte de temps!! Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 41

IV.5.2. Description du HOST VI et FPGA VI On utilise les blocs suivants : Figure IV.2. FPGA Open VI Reference [4] Ouvrir une référence au FPGA VI ou bitfile et cible FPGA vous spécifiez. Vous devez ouvrir une référence à la cible FPGA avant que vous puissiez communiquer entre HOST VI et FPGA VI. Vous pouvez télécharger et exécuter un seul FPGA VI à la fois sur une cible FPGA unique. Figure IV.3. Converter 12 bits to 64 bits Comme on a dit on a 64 valeurs chacune sur 12 bits. comme l implémentation se fait en parallèle, on a besoin d envoyer les premiers 64 bits de chaque valeur à notre design et ainsi de suite, donc on a besoin d écrire un programme qui transforme les 64 valeurs chacune de 12 bits à 12 valeurs chacune de 64 bits de façon que la première valeur est formée par l ensemble du premier bit du 64 pixels et la deuxième valeur est formée par l ensemble du deuxième bit du 64 pixels et ainsi de suite. Figure IV.4. Invoke Method [4] Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 42

On écrit les «Data64bits» dans cette FIFO à partir de l entrée «Data». Donc on a 12 valeurs dans cette FIFO chacune de 64 bits. Figure IV.5. FIFO Read [4] Une fois les données se trouvent dans le FIFO, on passe à FPGA VI pour les lire et commencer le traitement. Figure IV.6. FPGA I/O Node [4] On utilise «FPGA I/O Node» pour transformer notre design qui est écrit en VHDL «filterdesign_behavioral.vhdl» et le mettre dans ce bloc. Ainsi on précise les entrées et les sorties de ce bloc en accord avec les entrées et les sorties du VHDL. Cette étape se fait en utilisant l «importation d'ip externe dans LabVIEW FPGA avec le nœud CLIP» (voir ANNEXE E). Il faut mettre ce bloc dans un «Timed Loop» pour assurer l exécution séquentielle de notre algorithme. Donc on a 64 entrées (chacune d un seul bit) pour entrer les valeurs des pixels bit après bit, de plus on a une entrée «start» et une autre «clr». De même on a 64 sorties (chacune d un seul bit) pour les résultats finaux.. Figure IV.7. FIFO Write [4] Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 43

Après le traitement des données, on a besoin de sauvegarder les nouvelles valeurs dans une autre FIFO. Et comme on a vu dans l algorithme qui est écrit en VHDL, les 64 sorties sont chacune d un seul bit et les résultats du calcul sont obtenues en parallèle, donc on sauvegarde les résultats dans une FIFO avec un nombre d éléments égal à 12 chacun de 64 bits. Après chaque horloge en prend les 64 bits et on les met dans un tableau et à la fin du traitement en les sauvegarde dans la FIFO. Figure IV.8. Invoke Method [4] Les résultats se trouvent dans la FIFO, il reste de les lire. Le FIFO contient 12 valeurs chacune des 12 bits. Figure IV.9. Converter 64 bits to 12 bits [4] Les 12 valeurs provenant de la FIFO sont chacune de 64 bits. Donc on a besoin de les transformer pour obtenir les 64 valeurs chacune de 12 bits. Donc on prend l ensemble du premier bit des 12 valeurs pour former la première valeur, puis on prend l ensemble du deuxième bit des 12 valeurs pour former la deuxième valeur et ainsi de suite jusqu'à la soixante quatrième valeur. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 44

IV.6. Résultats On prend 64 pixels, on les traite puis on les affiche. Notre design est supporté avec cet FPGA ceci indique que notre design est assez petit car il contient de simple logique comme additionneurs série, registres à décalage, multiplexeurs, et machine d état. D autre part, le temps d exécution est assez petit car on utilise une horloge de 40MHz. Mais notre design peut être implémenté avec une horloge de 235.07 MHz comme on l a montré avec QUARTUS. De même en LabView FPGA, on a 6 étapes, et chaque étape a besoin de 12 cycles pour finir son travail. D où le temps est égal à 12*6*(1/40) = 1.8 [μs]. Note : on n entre pas le temps d écriture et de lecture des deux FIFOs dans le calcul de ce temps. Notre design écrit en VHDL peut supporter n importe quelle image et n importe quelle taille. Mais en LabView, puisque la méthode de sauvegarde consiste à sauvegarder chaque valeur sur 64 bits (c est la taille maximale supporter par la FIFO) donc on travaille sur 64 pixels seulement. C est pour cela on ne travaille pas sur une image réelle car avec 64 pixels l image perd sa résolution et si on va traiter une telle image avec notre algorithme, nous n observons pas la variation. C est pour cela on parle seulement du temps, la simplicité, la capacité de notre design. De même on n utilise aucun multiplieur dans notre algorithme qui est un point fort dans notre projet et qui rend le système très simple et n est pas très compliqué. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 45

Conclusion générale et perspectives Le travail dans ce rapport est un travail de collaboration entre le laboratoire des circuits logiques de la faculté de génie (ULFG1) et l université du Balamand, il concerne l implémentation d un algorithme de traitement d images sur un circuit du type FPGA en utilisant le logiciel LabView. Durant ce projet j ai eu la chance de travailler sur une nouvelle carte d acquisition NI- PCI 7830, savoir son fonctionnement, ses caractéristiques, son utilité. De même j ai pris la chance de se familiariser avec les logiciels QUARTUS et LabView FPGA. Du côté pratique du projet, je pense que c était un bon début pour entrer dans le domaine de travail, domaine de la grande responsabilité et de la grande compétence. Le projet est achevé, grâce à Dieu, avec succès ; notre algorithme peut être aussi plus généralisé avec les autres masques avec des petites modifications sur l algorithme et avec l agrandissement de la taille de l image. Une implémentation parallèle et efficace de filtre de moyennage a été mise sur FPGA en utilisant LabView comme une interface avec notre VHDL design, avec réduction du temps en comparaison avec l implémentation séquentielle. La zone sur FPGA a été réduite par une optimisation de l'opération arithmétique et de la mémoire. Pour les travaux futurs: Généralisation des autres masques (3*3) avec des quelques modifications sur notre algorithme. Tailles différentes de masques peuvent être étudié. Masques peuvent être appliqués aux images 3D. solution alternative à labview est d implémenter l'interface en utilisant un processeur à l'intérieur du FPGA. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 46

Avantage: Fournit une interface de bus plus large entre le processeur et FPGA (64 vs 1024 bits). Inconvénient: On a besoin d écrire en langage C par exemple pour implémenter une telle interface, tandis que dans LabView la plupart de cette fonction est disponible dans sa bibliothèque. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 47

Références [1] IMPLEMENTATION OF IMAGE PROCESSING ALGORITHMS ON FPGA HARDWARE By Anthony Edward Nelson, Thesis Submitted to the Faculty of the Graduate School of Vanderbilt University in partial fulfillment of the requirements for the degree of MASTER OF SCIENCE in Electrical Engineering, May 2000, Nashville, TN. [2] Ms. PRIYANKA S. CHIKKALI, Prof. K. PRABHUSHETTY, FPGA based Image Edge Detection and Segmentation, (IJAEST) INTERNATIONAL JOURNAL OF ADVANCED ENGINEERING SCIENCES AND TECHNOLOGIES, Vol No. 9, Issue No. 2, 187 192 http://www.ijaest.iserp.org [3] Cours traitement d image Dr. Mohamad KHALIL. [4] http://www.ni.com, site officiel du «National Instruments». Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 48

ANNEXE A : MATLAB M-FILES «ro_filt.m» function output_image = ro_filt(image_file,order); %% filename: ro_filt.m % author: Tony Nelson % date: 1/11/00 % detail: performs basic 3x3 rank order filtering % input_image = LoadImage(image_file); % loads image into input_image [ylength,xlength] = size(input_image); % determines size of input image output_image(1:ylength,1:xlength) = zeros; %inits output_image % loops to simulate SE window passing over image for y=1:ylength-2 for x=1:xlength-2 window = [input_image(y:(y+2),x:(x+2))]; window_v = [[window(1,1:3)] [window(2,1:3)] [window(3,1:3)]]; sorted_list = sort(window_v); output_image(y+1,x+1) = sorted_list(order); sorted_list(order); end end %plots ro filtered image figure; image(output_image) colormap(gray(256)); title('rank Order Filter Output'); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 49

ANNEXE B: VHDL SOURCE FILES «window_3x3.vhd» ----------------------------------------------------------------------- --- -- filename: window_3x3.vhd -- author: Tony Nelson -- date: 12/13/99 -- -- detail: 3x3 window generator -- -- limits: none ----------------------------------------------------------------------- ---- library IEEE; use IEEE.std_logic_1164.all; entity window_3x3 is generic ( vwidth: integer:=8 ); port ( Clk : in std_logic; RSTn : in std_logic; D : in std_logic_vector(vwidth-1 downto 0); w11 : out std_logic_vector(vwidth -1 downto 0); w12 : out std_logic_vector(vwidth -1 downto 0); w13 : out std_logic_vector(vwidth -1 downto 0); w21 : out std_logic_vector(vwidth -1 downto 0); w22 : out std_logic_vector(vwidth-1 downto 0); w23 : out std_logic_vector(vwidth -1 downto 0); w31 : out std_logic_vector(vwidth -1 downto 0); w32 : out std_logic_vector(vwidth -1 downto 0); w33 : out std_logic_vector(vwidth -1 downto 0); DV : out std_logic:='0' ); end window_3x3; architecture window_3x3 of window_3x3 is component fifo_128x8u PORT ( data : IN STD_LOGIC_VECTOR (7 DOWNTO 0); wrreq : IN STD_LOGIC ; rdreq : IN STD_LOGIC ; clock : IN STD_LOGIC ; aclr : IN STD_LOGIC ; q : OUT STD_LOGIC_VECTOR (7 DOWNTO 0); full : OUT STD_LOGIC ; empty : OUT STD_LOGIC ; usedw : OUT STD_LOGIC_VECTOR (6 DOWNTO 0) ); END component fifo_128x8u; signal a11 : std_logic_vector(vwidth-1 downto 0); signal a12 : std_logic_vector(vwidth-1 downto 0); signal a13 : std_logic_vector(vwidth-1 downto 0); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 50

signal a21 : std_logic_vector(vwidth-1 downto 0); signal a22 : std_logic_vector(vwidth-1 downto 0); signal a23 : std_logic_vector(vwidth-1 downto 0); signal a31 : std_logic_vector(vwidth-1 downto 0); signal a32 : std_logic_vector(vwidth-1 downto 0); signal a33 : std_logic_vector(vwidth-1 downto 0); --fifoa signals signal clear : std_logic; signal wrreqa : std_logic:='1'; signal rdreqa : std_logic:='0'; signal ofulla : std_logic; signal oemptya : std_logic; signal ofifoa : std_logic_vector(vwidth-1 downto 0); signal ousedwa : std_logic_vector(vwidth-2 downto 0); --fifob signals signal wrreqb : std_logic:='0'; signal rdreqb : std_logic:='0'; signal ofullb : std_logic; signal oemptyb : std_logic; signal ofifob : std_logic_vector(vwidth-1 downto 0); signal ousedwb : std_logic_vector(vwidth-2 downto 0); signal dwrreqb: std_logic:='0'; -- signals for DV coordination signal ddddddddddv: std_logic:='0'; signal dddddddddv: std_logic; signal ddddddddv: std_logic; signal dddddddv: std_logic; signal ddddddv: std_logic; signal dddddv: std_logic; signal ddddv: std_logic; signal dddv: std_logic; signal ddv: std_logic; begin fifoa: fifo_128x8u port map ( data => a13, wrreq => wrreqa, rdreq => rdreqa, clock => Clk, aclr => clear, q => ofifoa, full => ofulla, empty => oemptya, usedw => ousedwa ); fifob: fifo_128x8u port map ( data => a23, wrreq => wrreqb, rdreq => rdreqb, clock => Clk, aclr => clear, q => ofifob, full => ofullb, empty => oemptyb, usedw => ousedwb ); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 51

clear <= not(rstn); clock: process(clk,rstn) begin if RSTn = '0' then a11 <= (others=>'0'); a12 <= (others=>'0'); a13 <= (others=>'0'); a21 <= (others=>'0'); a22 <= (others=>'0'); a23 <= (others=>'0'); a31 <= (others=>'0'); a32 <= (others=>'0'); a33 <= (others=>'0'); w11 <= (others=>'0'); w12 <= (others=>'0'); w13 <= (others=>'0'); w21 <= (others=>'0'); w22 <= (others=>'0'); w23 <= (others=>'0'); w31 <= (others=>'0'); w32 <= (others=>'0'); w33 <= (others=>'0'); wrreqa <= '0'; wrreqb <= '0'; dddddddddv <= '0'; ddddddddv <= '0'; dddddddv <= '0'; ddddddv <= '0'; dddddv <= '0'; ddddv <= '0'; dddv <= '0'; ddv <= '0'; DV <= '0'; elsif rising_edge(clk) then a11 <= D; a12 <= a11; a13 <= a12; a21 <= ofifoa; a22 <= a21; a23 <= a22; a31 <= ofifob; a32 <= a31; a33 <= a32; w11 <= a11; w12 <= a12; w13 <= a13; w21 <= a21; w22 <= a22; w23 <= a23; w31 <= a31; w32 <= a32; w33 <= a33; wrreqa <= '1'; wrreqb <= dwrreqb; dddddddddv <= ddddddddddv; ddddddddv <= dddddddddv; dddddddv <= ddddddddv; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 52

ddddddv <= dddddddv; dddddv <= ddddddv; ddddv <= dddddv; dddv <= ddddv; ddv <= dddv; DV <= ddv; end process; req: process(clk) begin if rising_edge(clk) then if ousedwa = "1111011" then rdreqa <= '1'; dwrreqb <= '1'; if ousedwb = "1111011" then rdreqb <= '1'; elsif ousedwb = "1111100" then ddddddddddv <= '1'; end process; end window_3x3; «sort_3x3.vhd» ----------------------------------------------------------------------- --- -- filename: sort_3x3.vhd -- author: Tony Nelson -- date: 12/15/99 -- -- detail: 3x3 sorting algorithm. sorts input 3x3 window to output -- vectors from lowest to highest. s1 <= L, s5 <= M, S <= H. -- -- limits: none -------------------------------------------------------------- -------- ----- library IEEE; use IEEE.std_logic_1164.all; entity sort_3x3 is generic ( vwidth: integer:=8 ); port ( Clk : in std_logic; RSTn : in std_logic; w11 : in std_logic_vector((vwidth -1) downto 0); w12 : in std_logic_vector((vwidth-1) downto 0); w13 : in std_logic_vector((vwidth -1) downto 0); w21 : in std_logic_vector((vwidth -1) downto 0); w22 : in std_logic_vector((vwidth -1) downto 0); w23 : in std_logic_vector((vwidth -1) downto 0); w31 : in std_logic_vector((vwidth-1) downto 0); w32 : in std_logic_vector((vwidth -1) downto 0); w33 : in std_logic_vector((vwidth -1) downto 0); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 53

DVw : in std_logic; DVs : out std_logic; s1 : out std_logic_vector(vwidth -1 downto 0); s2 : out std_logic_vector(vwidth-1 downto 0); s3 : out std_logic_vector(vwidth -1 downto 0); s4 : out std_logic_vector(vwidth -1 downto 0); s5 : out std_logic_vector(vwidth -1 downto 0); s6 : out std_logic_vector(vwidth -1 downto 0); s7 : out std_logic_vector(vwidth -1 downto 0); s8 : out std_logic_vector(vwidth -1 downto 0); s9 : out std_logic_vector(vwidth -1 downto 0) ); end sort_3x3; architecture sort_3x3 of sort_3x3 is -- compare signals signal c11_l: std_logic_vector((vwidth -1) downto 0); signal c11_h: std_logic_vector((vwidth-1) downto 0); signal c12_l: std_logic_vector((vwidth -1) downto 0); signal c12_h: std_logic_vector((vwidth -1) downto 0); signal c13_l: std_logic_vector((vwidth -1) downto 0); signal c13_h: std_logic_vector((vwidth -1) downto 0); signal c14_l: std_logic_vector((vwidth -1) downto 0); signal c14_h: std_logic_vector((vwidth -1) downto 0); signal c21_l: std_logic_vector((vwidth -1) downto 0); signal c21_h: std_logic_vector((vwidth -1) downto 0); signal c22_l: std_logic_vector((vwidth -1) downto 0); signal c22_h: std_logic_vector((vwidth -1) downto 0); signal c23_l: std_logic_vector((vwidth -1) downto 0); signal c23_h: std_logic_vector((vwidth -1) downto 0); signal c24_l: std_logic_vector((vwidth -1) downto 0); signal c24_h: std_logic_vector((vwidth-1) downto 0); signal c31_l: std_logic_vector((vwidth -1) downto 0); signal c31_h: std_logic_vector((vwidth -1) downto 0); signal c32_l: std_logic_vector((vwidth -1) downto 0); signal c32_h: std_logic_vector((vwidth -1) downto 0); signal c33_l: std_logic_vector((vwidth-1) downto 0); signal c33_h: std_logic_vector((vwidth -1) downto 0); signal c34_l: std_logic_vector((vwidth -1) downto 0); signal c34_h: std_logic_vector((vwidth -1) downto 0); signal c41_l: std_logic_vector((vwidth -1) downto 0); signal c41_h: std_logic_vector((vwidth -1) downto 0); signal c42_l: std_logic_vector((vwidth -1) downto 0); signal c42_h: std_logic_vector((vwidth -1) downto 0); signal c43_l: std_logic_vector((vwidth -1) downto 0); signal c43_h: std_logic_vector((vwidth -1) downto 0); signal c4a1_l: std_logic_vector((vwidth -1) downto 0); signal c4a1_h: std_logic_vector((vwidth -1) downto 0); signal c4a2_l: std_logic_vector((vwidth -1) downto 0); signal c4a2_h: std_logic_vector((vwidth -1) downto 0); signal c4b0_l: std_logic_vector((vwidth-1) downto 0); signal c4b0_h: std_logic_vector((vwidth -1) downto 0); signal c4b1_l: std_logic_vector((vwidth -1) downto 0); signal c4b1_h: std_logic_vector((vwidth -1) downto 0); signal c4b2_l: std_logic_vector((vwidth -1) downto 0); signal c4b2_h: std_logic_vector((vwidth -1) downto 0); signal c51_l: std_logic_vector((vwidth -1) downto 0); signal c51_h: std_logic_vector((vwidth -1) downto 0); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 54

signal c61_l: std_logic_vector((vwidth -1) downto 0); signal c61_h: std_logic_vector((vwidth -1) downto 0); signal c71_l: std_logic_vector((vwidth -1) downto 0); signal c71_h: std_logic_vector((vwidth -1) downto 0); signal c81_l: std_logic_vector((vwidth -1) downto 0); signal c81_h: std_logic_vector((vwidth -1) downto 0); signal c91_l: std_logic_vector((vwidth-1) downto 0); signal c91_h: std_logic_vector((vwidth -1) downto 0); signal c101_l: std_logic_vector((vwidth -1) downto 0); signal c101_h: std_logic_vector((vwidth -1) downto 0); signal c111_l: std_logic_vector((vwidth -1) downto 0); signal c111_h: std_logic_vector((vwidth -1) downto 0); -- register signals signal r11: std_logic_vector((vwidth -1) downto 0); signal r21: std_logic_vector((vwidth -1) downto 0); signal r31: std_logic_vector((vwidth -1) downto 0); signal r41: std_logic_vector((vwidth-1) downto 0); signal r42: std_logic_vector((vwidth -1) downto 0); signal r43: std_logic_vector((vwidth -1) downto 0); signal r4a1: std_logic_vector((vwidth -1) downto 0); signal r4a2: std_logic_vector((vwidth -1) downto 0); signal r4a3: std_logic_vector((vwidth-1) downto 0); signal r4a4: std_logic_vector((vwidth -1) downto 0); signal r4a5: std_logic_vector((vwidth -1) downto 0); signal r4b1: std_logic_vector((vwidth -1) downto 0); signal r4b4: std_logic_vector((vwidth -1) downto 0); signal r4b5: std_logic_vector((vwidth -1) downto 0); signal r51: std_logic_vector((vwidth -1) downto 0); signal r52: std_logic_vector((vwidth -1) downto 0); signal r53: std_logic_vector((vwidth -1) downto 0); signal r54: std_logic_vector((vwidth-1) downto 0); signal r55: std_logic_vector((vwidth -1) downto 0); signal r56: std_logic_vector((vwidth -1) downto 0); signal r57: std_logic_vector((vwidth -1) downto 0); signal r61: std_logic_vector((vwidth -1) downto 0); signal r62: std_logic_vector((vwidth-1) downto 0); signal r63: std_logic_vector((vwidth -1) downto 0); signal r64: std_logic_vector((vwidth -1) downto 0); signal r65: std_logic_vector((vwidth -1) downto 0); signal r66: std_logic_vector((vwidth -1) downto 0); signal r67: std_logic_vector((vwidth-1) downto 0); signal r71: std_logic_vector((vwidth -1) downto 0); signal r72: std_logic_vector((vwidth -1) downto 0); signal r73: std_logic_vector((vwidth -1) downto 0); signal r74: std_logic_vector((vwidth -1) downto 0); signal r75: std_logic_vector((vwidth-1) downto 0); signal r76: std_logic_vector((vwidth -1) downto 0); signal r77: std_logic_vector((vwidth -1) downto 0); signal r81: std_logic_vector((vwidth -1) downto 0); signal r82: std_logic_vector((vwidth -1) downto 0); signal r83: std_logic_vector((vwidth-1) downto 0); signal r84: std_logic_vector((vwidth -1) downto 0); signal r85: std_logic_vector((vwidth -1) downto 0); signal r86: std_logic_vector((vwidth -1) downto 0); signal r87: std_logic_vector((vwidth -1) downto 0); signal r91: std_logic_vector((vwidth -1) downto 0); signal r92: std_logic_vector((vwidth -1) downto 0); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 55

signal r93: std_logic_vector((vwidth -1) downto 0); signal r94: std_logic_vector((vwidth -1) downto 0); signal r95: std_logic_vector((vwidth -1) downto 0); signal r96: std_logic_vector((vwidth -1) downto 0); signal r97: std_logic_vector((vwidth -1) downto 0); signal r101: std_logic_vector((vwidth -1) downto 0); signal r102: std_logic_vector((vwidth -1) downto 0); signal r103: std_logic_vector((vwidth -1) downto 0); signal r104: std_logic_vector((vwidth -1) downto 0); signal r105: std_logic_vector((vwidth -1) downto 0); signal r106: std_logic_vector((vwidth -1) downto 0); signal r107: std_logic_vector((vwidth -1) downto 0); signal r111: std_logic_vector((vwidth -1) downto 0); signal r112: std_logic_vector((vwidth -1) downto 0); signal r113: std_logic_vector((vwidth -1) downto 0); signal r114: std_logic_vector((vwidth -1) downto 0); signal r115: std_logic_vector((vwidth -1) downto 0); signal r116: std_logic_vector((vwidth-1) downto 0); signal r117: std_logic_vector((vwidth -1) downto 0); -- signals for DV coordination signal ddddddddddddddv: std_logic:='0'; signal dddddddddddddv: std_logic; signal ddddddddddddv: std_logic; signal dddddddddddv: std_logic ; signal ddddddddddv: std_logic; signal dddddddddv: std_logic; signal ddddddddv: std_logic; signal dddddddv: std_logic; signal ddddddv: std_logic; signal dddddv: std_logic; signal ddddv: std_logic; signal dddv: std_logic; signal ddv: std_logic; begin process(clk,rstn) begin if RSTn = '0' then c11_l <= (others=>'0'); c11_h <= (others=>'0'); c12_l <= (others=>'0'); c12_h <= (others=>'0'); c13_l <= (others=>'0'); c13_h <= (others=>'0'); c14_l <= (others=>'0'); c14_h <= (others=>'0'); c21_l <= (others=>'0'); c21_h <= (others=>'0'); c22_l <= (others=>'0'); c22_h <= (others=>'0'); c23_l <= (others=>'0'); c23_h <= (others=>'0'); c24_l <= (others=>'0'); c24_h <= (others=>'0'); c31_l <= (others=>'0'); c31_h <= (others=>'0'); c32_l <= (others=>'0'); c32_h <= (others=>'0'); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 56

c33_l <= (others=>'0'); c33_h <= (others=>'0'); c34_l <= (others=>'0'); c34_h <= (others=>'0'); c41_l <= (others=>'0'); c41_h <= (others=>'0'); c42_l <= (others=>'0'); c42_h <= (others=>'0'); c43_l <= (others=>'0'); c43_h <= (others=>'0'); c4a1_l <= (others=>'0'); c4a1_h <= (others=>'0'); c4a2_l <= (others=>'0'); c4a2_h <= (others=>'0'); c4b0_l <= (others=>'0'); c4b0_h <= (others=>'0'); c4b1_l <= (others=>'0'); c4b1_h <= (others=>'0'); c4b2_l <= (others=>'0'); c4b2_h <= (others=>'0'); c51_l <= (others=>'0'); c51_h <= (others=>'0'); c61_l <= (others=>'0'); c61_h <= (others=>'0'); c71_l <= (others=>'0'); c71_h <= (others=>'0'); c81_l <= (others=>'0'); c81_h <= (others=>'0'); c91_l <= (others=>'0'); c91_h <= (others=>'0'); c101_l <= (others=>'0'); c101_h <= (others=>'0'); c111_l <= (others=>'0'); c111_h <= (others=>'0'); r11 <= (others=>'0'); r21 <= (others=>'0'); r31 <= (others=>'0'); r41 <= (others=>'0'); r42 <= (others=>'0'); r43 <= (others=>'0'); r4a1 <= (others=>'0'); r4a2 <= (others=>'0'); r4a3 <= (others=>'0'); r4a4 <= (others=>'0'); r4a5 <= (others=>'0'); r4b1 <= (others=>'0'); r4b4 <= (others=>'0'); r4b5 <= (others=>'0'); r51 <= (others=>'0'); r52 <= (others=>'0'); r53 <= (others=>'0'); r54 <= (others=>'0'); r55 <= (others=>'0'); r56 <= (others=>'0'); r57 <= (others=>'0'); r61 <= (others=>'0'); r62 <= (others=>'0'); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 57

r63 <= (others=>'0'); r64 <= (others=>'0'); r65 <= (others=>'0'); r66 <= (others=>'0'); r67 <= (others=>'0'); r71 <= (others=>'0'); r72 <= (others=>'0'); r73 <= (others=>'0'); r74 <= (others=>'0'); r75 <= (others=>'0'); r76 <= (others=>'0'); r77 <= (others=>'0'); r81 <= (others=>'0'); r82 <= (others=>'0'); r83 <= (others=>'0'); r84 <= (others=>'0'); r85 <= (others=>'0'); r86 <= (others=>'0'); r87 <= (others=>'0'); r91 <= (others=>'0'); r92 <= (others=>'0'); r93 <= (others=>'0'); r94 <= (others=>'0'); r95 <= (others=>'0'); r96 <= (others=>'0'); r97 <= (others=>'0'); r101 <= (others=>'0'); r102 <= (others=>'0'); r103 <= (others=>'0'); r104 <= (others=>'0'); r105 <= (others=>'0'); r106 <= (others=>'0'); r107 <= (others=>'0'); r111 <= (others=>'0'); r112 <= (others=>'0'); r113 <= (others=>'0'); r114 <= (others=>'0'); r115 <= (others=>'0'); r116 <= (others=>'0'); r117 <= (others=>'0'); s1 <= (others=>'0'); s2 <= (others=>'0'); s3 <= (others=>'0'); s4 <= (others=>'0'); s5 <= (others=>'0'); s6 <= (others=>'0'); s7 <= (others=>'0'); s8 <= (others=>'0'); s9 <= (others=>'0'); dddddddddddddv <= '0'; ddddddddddddv <= '0'; dddddddddddv <= '0'; ddddddddddv <= '0'; dddddddddv <= '0'; ddddddddv <= '0'; dddddddv <= '0'; ddddddv <= '0'; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 58

dddddv <= '0'; ddddv <= '0'; dddv <= '0'; ddv <= '0'; DVs <= '0'; elsif rising_edge(clk) then if DVw = '1' then -- level 1 if w11 < w12 then c11_l <= w11; c11_h <= w12; else c11_l <= w12; c11_h <= w11; if w13 < w21 then c12_l <= w13; c12_h <= w21; else c12_l <= w21; c12_h <= w13; if w22 < w23 then c13_l <= w22; c13_h <= w23; else c13_l <= w23; c13_h <= w22; if w31 < w32 then c14_l <= w31; c14_h <= w32; else c14_l <= w32; c14_h <= w31; r11 <= w33; -- level 2 if c11_l < c12_l then c21_l <= c11_l; c21_h <= c12_l; else c21_l <= c12_l; c21_h <= c11_l; if c11_h < c12_h then c22_l <= c11_h; c22_h <= c12_h; else c22_l <= c12_h; c22_h <= c11_h; if c13_l < c14_l then c23_l <= c13_l; c23_h <= c14_l; else c23_l <= c14_l; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 59

c23_h <= c13_l; if c13_h < c14_h then c24_l <= c13_h; c24_h <= c14_h; else c24_l <= c14_h; c24_h <= c13_h; r21 <= r11; -- level 3 if c21_l < c23_l then c31_l <= c21_l; c31_h <= c23_l; else c31_l <= c23_l; c31_h <= c21_l; if c21_h < c23_h then c32_l <= c21_h; c32_h <= c23_h; else c32_l <= c23_h; c32_h <= c21_h; if c22_l < c24_l then c33_l <= c22_l; c33_h <= c24_l; else c33_l <= c24_l; c33_h <= c22_l; if c22_h < c24_h then c34_l <= c22_h; c34_h <= c24_h; else c34_l <= c24_h; c34_h <= c22_h; r31 <= r21; -- level 4 r41 <= c31_l; if c31_h < c32_l then c41_l <= c31_h; c41_h <= c32_l; else c41_l <= c32_l; c41_h <= c31_h; if c32_h < c33_l then c42_l <= c32_h; c42_h <= c33_l; else c42_l <= c33_l; c42_h <= c32_h; if c33_h < c34_l then Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 60

c43_l <= c33_h; c43_h <= c34_l; else c43_l <= c34_l; c43_h <= c33_h; r42 <= c34_h; r43 <= r31; -- level 4a r4a1 <= r41; if c41_l < c42_h then c4a1_l <= c41_l; c4a1_h <= c42_h; else c4a1_l <= c42_h; c4a1_h <= c41_l; if c41_h < c42_l then c4a2_l <= c41_h; c4a2_h <= c42_l; else c4a2_l <= c42_l; c4a2_h <= c41_h; r4a2 <= c43_l; r4a3 <= c43_h; r4a4 <= r42; r4a5 <= r43; -- level 4b r4b1 <= r4a1; if c4a1_l < c4a2_l then c4b0_l <= c4a1_l; c4b0_h <= c4a2_l; else c4b0_l <= c4a2_l; c4b0_h <= c4a1_l; if c4a2_h < r4a2 then c4b1_l <= c4a2_h; c4b1_h <= r4a2; else c4b1_l <= r4a2; c4b1_h <= c4a2_h; if c4a1_h < r4a3 then 4b2_L <= c4a1_h; c4b2_h <= r4a3; else c4b2_l <= r4a3; c4b2_h <= c4a1_h; r4b4 <= r4a4; r4b5 <= r4a5; -- level 5 if r4b1 < r4b5 then c51_l <= r4b1; c51_h <= r4b5; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 61

else c51_l <= r4b5; c51_h <= r4b1; r51 <= c4b0_l; r52 <= c4b0_h; r53 <= c4b1_l; r54 <= c4b1_h; r55 <= c4b2_l; r56 <= c4b2_h; r57 <= r4b4; -- level 6 if r51 < c51_h then c61_l <= r51; c61_h <= c51_h; else c61_l <= c51_h; c61_h <= r51; r61 <= c51_l; -- L r62 <= r52; r63 <= r53; r64 <= r54; r65 <= r55; r66 <= r56; r67 <= r57; -- level 7 if r62 < c61_h then c71_l <= r62; c71_h <= c61_h; else c71_l <= c61_h; c71_h <= r62; r71 <= r61; -- L r72 <= c61_l; -- 2L r73 <= r63; r74 <= r64; r75 <= r65; r76 <= r66; r77 <= r67; -- level 8 if r73 < c71_h then c81_l <= r73; c81_h <= c71_h; else c81_l <= c71_h; c81_h <= r73; r81 <= r71; -- L r82 <= r72; -- 2L r83 <= c71_l; -- 3L r84 <= r74; r85 <= r75; r86 <= r76; r87 <= r77; -- level 9 Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 62

if r84 < c81_h then c91_l <= r84; c91_h <= c81_h; else c91_l <= c81_h; c91_h <= r84; r91 <= r81; -- L r92 <= r82; -- 2L r93 <= r83; -- 3L r94 <= c81_l; -- 4L r95 <= r85; r96 <= r86; r97 <= r87; -- level 10 if r95 < c91_h then c101_l <= r95; c101_h <= c91_h; else c101_l <= c91_h; c101_h <= r95; r101 <= r91; -- L r102 <= r92; -- 2L r103 <= r93; -- 3L r104 <= r94; -- 4L r105 <= c91_l; -- M r106 <= r96; r107 <= r97; -- level 11 if r106 < c101_h then c111_l <= r106; c111_h <= c101_h; else c111_l <= c101_h; c111_h <= r106; r111 <= r101; -- L r112 <= r102; -- 2L r113 <= r103; -- 3L r114 <= r104; -- 4L r115 <= r105; -- M r116 <= c101_l; -- 4L r117 <= r107; -- level 12 if r117 < c111_h then s8 <= r117; -- 2H s9 <= c111_h; -- H else s8 <= c111_h; -- 2H s9 <= r117; -- H s1 <= r111; -- L s2 <= r112; -- 2L s3 <= r113; -- 3L s4 <= r114; -- 4L s5 <= r115; -- M Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 63

s6 <= r116; -- 4H s7 <= c111_l; -- 3H dddddddddddddv <= ddddddddddddddv; ddddddddddddv <= dddddddddddddv; dddddddddddv <= ddddddddddddv; ddddddddddv <= dddddddddddv; dddddddddv <= ddddddddddv; ddddddddv <= dddddddddv; dddddddv <= ddddddddv; ddddddv <= dddddddv; dddddv <= ddddddv; ddddv <= dddddv; dddv <= ddddv; ddv <= dddv; DVs <= ddv; if DVw = '1' then ddddddddddddddv <= '1'; end process; end sort_3x3; «rc_counter.vhd» ----------------------------------------------------------------------- --- -- filename: rc_counter.vhd -- author: Tony Nelson -- date: 12/22/99 -- -- detail: row/column counter -- -- limits: none ------------------------------------------- --------------------------- ----- library IEEE; use IEEE.std_logic_1164.all; entity rc_counter is generic ( num_cols: integer:=128; num_rows: integer:=128 ); port ( Clk : in std_logic; RSTn : in std_logic; En : in std_logic; ColPos : out integer; RowPos : out integer ); end rc_counter; architecture rc_counter of rc_counter is begin process(rstn,clk,en) variable ColPos_var: integer:=0; variable RowPos_var: integer:=0; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 64

begin if RSTn = '0' then ColPos_var := -1; ColPos <= 0; RowPos_var := 0; RowPos <= 0; elsif rising_edge(clk) then if En = '1' then ColPos_var := ColPos_var +1; if ColPos_var = num_cols then RowPos_var := RowPos_var +1; ColPos_var := 0; if RowPos_var = num_rows then RowPos_var := 0; ColPos <= ColPos_var; RowPos <= RowPos_var; end process; end rc_counter; «ro_filt_3x3.vhd» -------------------------------------------------------------- -------- ---- -- filename: ro_filt_3x3.vhd -- author: Tony Nelson -- date: 12/21/99 -- -- detail: 3x3 Rank Order Filter. Generic order sets filter order. -- order: integer:= 5 is a Median Filter. -- -- limits: none ----------------------------------- ----------------------------------- ----- library IEEE; use IEEE.std_logic_1164.all; entity ro_filt_3x3 is generic ( vwidth: integer:=8; order: integer:=4; num_cols: integer:=128; num_rows: integer:=128 ); port ( Clk : in std_logic; RSTn : in std_logic; D : in std_logic_vector(vwidth-1 downto 0); Dout : out std_logic_vector(vwidth -1 downto 0); DV : out std_logic ); end ro_filt_3x3; architecture ro_filt_3x3 of ro_filt_3x3 is component sort_3x3 Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 65

generic ( vwidth: integer:=8 ); port ( Clk : in std_logic; RSTn : in std_logic; w11 : in std_logic_vector((vwidth -1) downto 0); w12 : in std_logic_vector((vwidth -1) downto 0); w13 : in std_logic_vector((vwidth -1) downto 0); w21 : in std_logic_vector((vwidth-1) downto 0); w22 : in std_logic_vector((vwidth -1) downto 0); w23 : in std_logic_vector((vwidth -1) downto 0); w31 : in std_logic_vector((vwidth -1) downto 0); w32 : in std_logic_vector((vwidth -1) downto 0); w33 : in std_logic_vector((vwidth-1) downto 0); DVw : in std_logic; DVs : out std_logic; s1 : out std_logic_vector(vwidth -1 downto 0); s2 : out std_logic_vector(vwidth -1 downto 0); s3 : out std_logic_vector(vwidth -1 downto 0); s4 : out std_logic_vector(vwidth-1 downto 0); s5 : out std_logic_vector(vwidth -1 downto 0); s6 : out std_logic_vector(vwidth -1 downto 0); s7 : out std_logic_vector(vwidth -1 downto 0); s8 : out std_logic_vector(vwidth -1 downto 0); s9 : out std_logic_vector(vwidth -1 downto 0) ); end component sort_3x3; signal w11: std_logic_vector((vwidth -1) downto 0); signal w12: std_logic_vector((vwidth -1) downto 0); signal w13: std_logic_vector((vwidth -1) downto 0); signal w21: std_logic_vector((vwidth -1) downto 0); signal w22: std_logic_vector((vwidth-1) downto 0); signal w23: std_logic_vector((vwidth -1) downto 0); signal w31: std_logic_vector((vwidth -1) downto 0); signal w32: std_logic_vector((vwidth -1) downto 0); signal w33: std_logic_vector((vwidth -1) downto 0); signal DVw: std_logic; signal DVs: std_logic; signal s1: std_logic_vector(vwidth -1 downto 0); signal s2: std_logic_vector(vwidth -1 downto 0); signal s3: std_logic_vector(vwidth -1 downto 0); signal s4: std_logic_vector(vwidth -1 downto 0); signal s5: std_logic_vector(vwidth-1 downto 0); signal s6: std_logic_vector(vwidth -1 downto 0); signal s7: std_logic_vector(vwidth -1 downto 0); signal s8: std_logic_vector(vwidth -1 downto 0); signal s9: std_logic_vector(vwidth -1 downto 0); component window_3x3 generic ( vwidth: integer:=8 ); port ( Clk : in std_logic; RSTn : in std_logic; D : in std_logic_vector(vwidth-1 downto 0); w11 : out std_logic_vector(vwidth -1 downto 0); w12 : out std_logic_vector(vwidth -1 downto 0); w13 : out std_logic_vector(vwidth-1 downto 0); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 66

w21 : out std_logic_vector(vwidth -1 downto 0); w22 : out std_logic_vector(vwidth -1 downto 0); w23 : out std_logic_vector(vwidth -1 downto 0); w31 : out std_logic_vector(vwidth -1 downto 0); w32 : out std_logic_vector(vwidth-1 downto 0); w33 : out std_logic_vector(vwidth -1 downto 0); DV : out std_logic:='0' ); end component window_3x3; component rc_counter generic ( num_cols: integer:=128; num_rows: integer:=128 ); port ( Clk : in std_logic; RSTn : in std_logic; En : in std_logic; ColPos : out integer; RowPos : out integer ); end component rc_counter; signal ColPos: integer:=0; signal RowPos: integer:=0; signal ColPos_c: integer:=0; -- corrected positions signal RowPos_c: integer:=0; signal rt1: integer:=0; signal rt2: integer:=0; signal rt3: integer:=0; signal rt4: integer:=0; signal rt5: integer:=0; signal rt6: integer:=0; signal rt7: integer:=0; signal rt8: integer:=0; signal rt9: integer:=0; signal rt10: integer:=0; signal rt11: integer:=0; signal rt12: integer:=0; signal rt13: integer:=0; signal rt14: integer:=0; signal rt15: integer:=0; signal rt16: integer:=0; signal flag: std_logic:='0'; begin sort_3x3x: sort_3x3 generic map ( vwidth => 8 ) port map ( Clk => Clk, RSTn => RSTn, w11 => w11, w12 => w12, w13 => w13, w21 => w21, w22 => w22, w23 => w23, Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 67

w31 => w31, w32 => w32, w33 => w33, DVw => DVw, DVs => DVs, s1 => s1, s2 => s2, s3 => s3, s4 => s4, s5 => s5, s6 => s6, s7 => s7, s8 => s8, s9 => s9 ); window_3x3x: window_3x3 generic map ( vwidth => 8 ) port map ( Clk => Clk, RSTn => RSTn, D => D, w11 => w11, w12 => w12, w13 => w13, w21 => w21, w22 => w22, w23 => w23, w31 => w31, w32 => w32, w33 => w33, DV => DVw ); rc_counterx: rc_counter generic map ( num_cols => 128, num_rows => 128 ) port map ( Clk => Clk, RSTn => RSTn, En => RSTn, ColPos => ColPos, RowPos => RowPos ); ro_filt_proc: process(rstn,clk) begin if RSTn = '0' then ColPos_c <= 0; rt1 <= 0; rt2 <= 0; rt3 <= 0; rt4 <= 0; rt5 <= 0; rt6 <= 0; rt7 <= 0; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 68

rt8 <= 0; rt9 <= 0; rt10 <= 0; rt11 <= 0; rt12 <= 0; rt13 <= 0; rt14 <= 0; rt15 <= 0; rt16 <= 0; RowPos_c <= 0; Dout <= (others=>'0'); DV <= '0'; flag <= '0'; elsif rising_edge(clk) then -- counter correction ColPos_c <= ((ColPos-16) mod 128); rt1 <= ((RowPos-1) mod 128); rt2 <= rt1; rt3 <= rt2; rt4 <= rt3; rt5 <= rt4; rt6 <= rt5; rt7 <= rt6; rt8 <= rt7; rt9 <= rt8; rt10 <= rt9; rt11 <= rt10; rt12 <= rt11; rt13 <= rt12; rt14 <= rt13; rt15 <= rt14; rt16 <= rt15; RowPos_c <= rt16; -- screen edge detection if (ColPos_c = num_cols-1) or (RowPos_c = num_rows-1) or (ColPos_c = num_cols-2) or (RowPos_c = 0) then Dout <= (others=>'0'); else if order = 1 then Dout <= s1; elsif order = 2 then Dout <= s2; elsif order = 3 then Dout <= s3; elsif order = 4 then Dout <= s4; elsif order = 5 then Dout <= s5; elsif order = 6 then Dout <= s6; elsif order = 7 then Dout <= s7; elsif order = 8 then Dout <= s8; elsif order = 9 then Dout <= s9; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 69

if ColPos >= 16 and RowPos >= 1 then DV <= '1'; flag <= '1'; elsif flag = '1' then DV <= '1'; else DV <= '0'; end process; end ro_filt_3x3; «MyFilterCell.vhdl» LIBRARY ieee; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; ENTITY MyFilterCell IS PORT( Datain IWest INorth ISouth IEast Dataout : OUT STD_LOGIC; clk clr SelDir : IN STD_LOGIC_VECTOR (1 DOWNTO 0); ShEn SelIn : IN STD_LOGIC ); END MyFilterCell ; ARCHITECTURE Behavioral OF MyFilterCell IS signal ShftReg: STD_LOGIC_VECTOR(11 downto 0); signal Regint: STD_LOGIC; signal Dint: STD_LOGIC; signal DSel: STD_LOGIC; signal PSAdder: STD_LOGIC; signal NSAdder, SOut: STD_LOGIC; signal r1: STD_LOGIC_VECTOR (6 DOWNTO 0):=(others =>'0'); begin SACC:process (clr, clk) begin if clr = '1' then ShftReg <= (others=>'0'); elsif (clk'event and clk = '1') then if (ShEn = '1') then ShftReg <= (Dint & ShftReg(11 downto 1)); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 70

end process SACC; Dataout <= ShftReg(0); Dint <= Regint when (SelIn = '1') else SOut; ShiftInput: process (clr, clk) begin if (clr ='1') then Regint <= '0'; elsif (clk'event and clk = '1') then if (ShEn = '1') then Regint <= Datain; end process; NEWS: WITH SelDir SELECT DSel <= IWest WHEN "00", INorth WHEN "01", ISouth WHEN "10", IEast WHEN others; PSReg: process (clr, clk) begin if (clr = '1') then PSAdder <= '0'; elsif (clk'event and clk = '1') then PSAdder <= NSAdder; end process; NSAdder <= (DSel and ShftReg(0)) or (DSel and PSAdder) or (ShftReg(0) and PSAdder); SOut <= DSel xor ShftReg(0) xor PSAdder; end architecture behavioral; LIBRARY ieee; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; «ControlUnit.vhd» ENTITY ControlUnit IS port ( clk clr Start SelIn : OUT STD_LOGIC; ShEn : OUT STD_LOGIC; SelDir : OUT STD_LOGIC_VECTOR(1 downto 0) ); END ControlUnit; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 71

ARCHITECTURE behavioral OF ControlUnit IS signal Done12: STD_LOGIC; signal CtrRst: STD_LOGIC; signal NSMain, PSMain: STD_LOGIC_VECTOR(2 downto 0); signal Ctr4bit: integer range 0 to 15; signal SelInInt, ShEnInt: STD_LOGIC; signal SelDirInt: STD_LOGIC_VECTOR(1 downto 0); begin PSReg: process (clr, clk) begin if (clr = '1') then PSMain <= (others => '0'); elsif (clk'event and clk = '1') then PSMain <= NSMain; end process; NSIntOut: process (PSMain, Start, Done12) begin SelInInt <= '1'; ShEnInt <= '0'; SelDirInt <= (others => '0'); NSMain <= (others => '0'); CASE PSMain IS WHEN "000" => if (Start = '0') then ShEnInt <='0'; CtrRst <= '1'; SelDirInt <= "00"; SelInInt <= '1'; NSMain <= "000"; elsif (start='1') then ShEnInt <='1'; CtrRst <= '1'; SelDirInt <= "00"; SelInInt <= '1'; NSMain <= "001"; WHEN "001" => if (Done12 = '0') then SelInInt <= '1'; SelDirInt <= "00"; ShEnInt <= '1'; CtrRst <= '0'; NSMain <= "001"; elsif (Done12 = '1') then SelInInt <= '0'; SelDirInt <= "00"; ShEnInt <= '1'; CtrRst <= '1'; NSMain <= "011"; WHEN "011" => Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 72

if (Done12 = '0') then SelDirInt <= "00"; SelInInt <= '0'; ShEnInt <= '1'; CtrRst <= '0'; NSMain <= "011"; elsif (Done12 = '1') then SelDirInt <= "01"; SelInInt <= '0'; ShEnInt <= '1'; CtrRst <= '1'; NSMain <= "111"; WHEN "111" => if (Done12 = '0') then SelDirInt <= "01"; SelInInt <= '0'; ShEnInt <= '1'; CtrRst <= '0'; NSMain <= "111"; elsif (Done12 = '1') then SelDirInt <= "11"; SelInInt <= '0'; ShEnInt <= '1'; CtrRst <= '1'; NSMain <= "101"; WHEN "101" => if (Done12 = '0') then SelDirInt <= "11"; SelInInt <= '0'; ShEnInt <= '1'; CtrRst <= '0'; NSMain <= "101"; elsif (Done12 = '1') then SelDirInt <= "10"; SelInInt <= '0'; ShEnInt <= '1'; CtrRst <= '1'; NSMain <= "100"; WHEN "100" => if (Done12 = '0') then SelDirInt <= "10"; SelInInt <= '0'; ShEnInt <= '1'; CtrRst <= '0'; NSMain <= "100"; elsif (Done12 = '1') then SelDirInt <= "11"; SelInInt <= '1'; ShEnInt <= '1'; CtrRst <= '1'; NSMain <= "110"; WHEN "110" => if (Done12 = '0') then Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 73

SelDirInt <= "11"; SelInInt <= '0'; ShEnInt <= '1'; CtrRst <= '0'; NSMain <= "110"; elsif (Done12 = '1') then SelDirInt <= "00"; SelInInt <= '1'; ShEnInt <= '0'; CtrRst <= '1'; NSMain <= "010"; WHEN "010" => SelDirInt <= "00"; SelInInt <= '1'; ShEnInt <= '0'; CtrRst <= '1'; NSMain <= "010"; WHEN OTHERS => SelDirInt <= "00"; SelInInt <= '1'; ShEnInt <= '0'; CtrRst <= '1'; NSMain <= "000"; END CASE; END process; RegOut: process (clk) begin if (clk'event and clk = '1') then SelDir <= SelDirInt; SelIn <= SelInInt; ShEn <= ShEnInt; end process; Counter: process (clk) begin if (clk'event and clk ='1') then if (CtrRst = '1') then Ctr4bit <= 0; else Ctr4bit <= Ctr4bit + 1; end process; Done12 <= '1' WHEN Ctr4bit = 11 else '0'; end architecture behavioral; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 74

LIBRARY ieee; USE ieee.std_logic_1164.all; USE ieee.std_logic_arith.all; ENTITY filterdesign_behavioral IS «Myfilterdesign_behavioral.vhd» GENERIC(M: POSITIVE :=64; N: POSITIVE :=64); PORT( Datain0_0 Datain0_1 Datain0_2 Datain0_3 Datain0_4 Datain0_5 Datain0_6 Datain0_7 Datain1_0 Datain1_1 Datain1_2 Datain1_3 Datain1_4 Datain1_5 Datain1_6 Datain1_7 Datain2_0 Datain2_1 Datain2_2 Datain2_3 Datain2_4 Datain2_5 Datain2_6 Datain2_7 Datain3_0 Datain3_1 Datain3_2 Datain3_3 Datain3_4 Datain3_5 Datain3_6 Datain3_7 Datain4_0 Datain4_1 Datain4_2 Datain4_3 Datain4_4 Datain4_5 Datain4_6 Datain4_7 Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 75

Datain5_0 Datain5_1 Datain5_2 Datain5_3 Datain5_4 Datain5_5 Datain5_6 Datain5_7 Datain6_0 Datain6_1 Datain6_2 Datain6_3 Datain6_4 Datain6_5 Datain6_6 Datain6_7 Datain7_0 Datain7_1 Datain7_2 Datain7_3 Datain7_4 Datain7_5 Datain7_6 Datain7_7 Dataout0_0 : OUT STD_LOGIC; Dataout0_1 : OUT STD_LOGIC; Dataout0_2 : OUT STD_LOGIC; Dataout0_3 : OUT STD_LOGIC; Dataout0_4 : OUT STD_LOGIC; Dataout0_5 : OUT STD_LOGIC; Dataout0_6 : OUT STD_LOGIC; Dataout0_7 : OUT STD_LOGIC; Dataout1_0 : OUT STD_LOGIC; Dataout1_1 : OUT STD_LOGIC; Dataout1_2 : OUT STD_LOGIC; Dataout1_3 : OUT STD_LOGIC; Dataout1_4 : OUT STD_LOGIC; Dataout1_5 : OUT STD_LOGIC; Dataout1_6 : OUT STD_LOGIC; Dataout1_7 : OUT STD_LOGIC; Dataout2_0 : OUT STD_LOGIC; Dataout2_1 : OUT STD_LOGIC; Dataout2_2 : OUT STD_LOGIC; Dataout2_3 : OUT STD_LOGIC; Dataout2_4 : OUT STD_LOGIC; Dataout2_5 : OUT STD_LOGIC; Dataout2_6 : OUT STD_LOGIC; Dataout2_7 : OUT STD_LOGIC; Dataout3_0 : OUT STD_LOGIC; Dataout3_1 : OUT STD_LOGIC; Dataout3_2 : OUT STD_LOGIC; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 76

Dataout3_3 : OUT STD_LOGIC; Dataout3_4 : OUT STD_LOGIC; Dataout3_5 : OUT STD_LOGIC; Dataout3_6 : OUT STD_LOGIC; Dataout3_7 : OUT STD_LOGIC; Dataout4_0 : OUT STD_LOGIC; Dataout4_1 : OUT STD_LOGIC; Dataout4_2 : OUT STD_LOGIC; Dataout4_3 : OUT STD_LOGIC; Dataout4_4 : OUT STD_LOGIC; Dataout4_5 : OUT STD_LOGIC; Dataout4_6 : OUT STD_LOGIC; Dataout4_7 : OUT STD_LOGIC; Dataout5_0 : OUT STD_LOGIC; Dataout5_1 : OUT STD_LOGIC; Dataout5_2 : OUT STD_LOGIC; Dataout5_3 : OUT STD_LOGIC; Dataout5_4 : OUT STD_LOGIC; Dataout5_5 : OUT STD_LOGIC; Dataout5_6 : OUT STD_LOGIC; Dataout5_7 : OUT STD_LOGIC; Dataout6_0 : OUT STD_LOGIC; Dataout6_1 : OUT STD_LOGIC; Dataout6_2 : OUT STD_LOGIC; Dataout6_3 : OUT STD_LOGIC; Dataout6_4 : OUT STD_LOGIC; Dataout6_5 : OUT STD_LOGIC; Dataout6_6 : OUT STD_LOGIC; Dataout6_7 : OUT STD_LOGIC; Dataout7_0 : OUT STD_LOGIC; Dataout7_1 : OUT STD_LOGIC; Dataout7_2 : OUT STD_LOGIC; Dataout7_3 : OUT STD_LOGIC; Dataout7_4 : OUT STD_LOGIC; Dataout7_5 : OUT STD_LOGIC; Dataout7_6 : OUT STD_LOGIC; Dataout7_7 : OUT STD_LOGIC; clk clr start : IN STD_LOGIC ); END filterdesign_behavioral; ARCHITECTURE structural OF filterdesign_behavioral IS type STD_2D is array (0 to M+1, 0 to N+1) of STD_LOGIC; SIGNAL Datain : STD_2D; SIGNAL s : STD_2D; SIGNAL SelIn,ShEn : STD_LOGIC; SIGNAL SelDir : STD_LOGIC_VECTOR(1 downto 0); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 77

COMPONENT MyFilterCell IS PORT ( port Datain IWest INorth ISouth IEast Dataout : OUT STD_LOGIC; clk clr SelDir : IN STD_LOGIC_VECTOR (1 DOWNTO 0); ShEn SelIn : IN STD_LOGIC ); END COMPONENT; COMPONENT ControlUnit IS ( ); clk clr Start SelIn : OUT STD_LOGIC; ShEn : OUT STD_LOGIC; SelDir : OUT STD_LOGIC_VECTOR(1 downto 0) END COMPONENT; BEGIN Datain(1,1)<=Datain0_0; Datain(1,2)<=Datain0_1; Datain(1,3)<=Datain0_2; Datain(1,4)<=Datain0_3; Datain(1,5)<=Datain0_4; Datain(1,6)<=Datain0_5; Datain(1,7)<=Datain0_6; Datain(1,8)<=Datain0_7; Datain(2,1)<=Datain1_0; Datain(2,2)<=Datain1_1; Datain(2,3)<=Datain1_2; Datain(2,4)<=Datain1_3; Datain(2,5)<=Datain1_4; Datain(2,6)<=Datain1_5; Datain(2,7)<=Datain1_6; Datain(2,8)<=Datain1_7; Datain(3,1)<=Datain2_0; Datain(3,2)<=Datain2_1; Datain(3,3)<=Datain2_2; Datain(3,4)<=Datain2_3; Datain(3,5)<=Datain2_4; Datain(3,6)<=Datain2_5; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 78

Datain(3,7)<=Datain2_6; Datain(3,8)<=Datain2_7; Datain(4,1)<=Datain3_0; Datain(4,2)<=Datain3_1; Datain(4,3)<=Datain3_2; Datain(4,4)<=Datain3_3; Datain(4,5)<=Datain3_4; Datain(4,6)<=Datain3_5; Datain(4,7)<=Datain3_6; Datain(4,8)<=Datain3_7; Datain(5,1)<=Datain4_0; Datain(5,2)<=Datain4_1; Datain(5,3)<=Datain4_2; Datain(5,4)<=Datain4_3; Datain(5,5)<=Datain4_4; Datain(5,6)<=Datain4_5; Datain(5,7)<=Datain4_6; Datain(5,8)<=Datain4_7; Datain(6,1)<=Datain5_0; Datain(6,2)<=Datain5_1; Datain(6,3)<=Datain5_2; Datain(6,4)<=Datain5_3; Datain(6,5)<=Datain5_4; Datain(6,6)<=Datain5_5; Datain(6,7)<=Datain5_6; Datain(6,8)<=Datain5_7; Datain(7,1)<=Datain6_0; Datain(7,2)<=Datain6_1; Datain(7,3)<=Datain6_2; Datain(7,4)<=Datain6_3; Datain(7,5)<=Datain6_4; Datain(7,6)<=Datain6_5; Datain(7,7)<=Datain6_6; Datain(7,8)<=Datain6_7; Datain(8,1)<=Datain7_0; Datain(8,2)<=Datain7_1; Datain(8,3)<=Datain7_2; Datain(8,4)<=Datain7_3; Datain(8,5)<=Datain7_4; Datain(8,6)<=Datain7_5; Datain(8,7)<=Datain7_6; Datain(8,8)<=Datain7_7; Dataout0_0<=s(1,1); Dataout0_1<=s(1,2); Dataout0_2<=s(1,3); Dataout0_3<=s(1,4); Dataout0_4<=s(1,5); Dataout0_5<=s(1,6); Dataout0_6<=s(1,7); Dataout0_7<=s(1,8); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 79

Dataout1_0<=s(2,1); Dataout1_1<=s(2,2); Dataout1_2<=s(2,3); Dataout1_3<=s(2,4); Dataout1_4<=s(2,5); Dataout1_5<=s(2,6); Dataout1_6<=s(2,7); Dataout1_7<=s(2,8); Dataout2_0<=s(3,1); Dataout2_1<=s(3,2); Dataout2_2<=s(3,3); Dataout2_3<=s(3,4); Dataout2_4<=s(3,5); Dataout2_5<=s(3,6); Dataout2_6<=s(3,7); Dataout2_7<=s(3,8); Dataout3_0<=s(4,1); Dataout3_1<=s(4,2); Dataout3_2<=s(4,3); Dataout3_3<=s(4,4); Dataout3_4<=s(4,5); Dataout3_5<=s(4,6); Dataout3_6<=s(4,7); Dataout3_7<=s(4,8); Dataout4_0<=s(5,1); Dataout4_1<=s(5,2); Dataout4_2<=s(5,3); Dataout4_3<=s(5,4); Dataout4_4<=s(5,5); Dataout4_5<=s(5,6); Dataout4_6<=s(5,7); Dataout4_7<=s(5,8); Dataout5_0<=s(6,1); Dataout5_1<=s(6,2); Dataout5_2<=s(6,3); Dataout5_3<=s(6,4); Dataout5_4<=s(6,5); Dataout5_5<=s(6,6); Dataout5_6<=s(6,7); Dataout5_7<=s(6,8); Dataout6_0<=s(7,1); Dataout6_1<=s(7,2); Dataout6_2<=s(7,3); Dataout6_3<=s(7,4); Dataout6_4<=s(7,5); Dataout6_5<=s(7,6); Dataout6_6<=s(7,7); Dataout6_7<=s(7,8); Dataout7_0<=s(8,1); Dataout7_1<=s(8,2); Dataout7_2<=s(8,3); Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 80

Dataout7_3<=s(8,4); Dataout7_4<=s(8,5); Dataout7_5<=s(8,6); Dataout7_6<=s(8,7); Dataout7_7<=s(8,8); MyControlUnit: ControlUnit PORT MAP (clk,clr,start,selin,shen,seldir); MyFilterCell00: MyFilterCell PORT MAP ('0','0','0',s(1,0),s(0,1),s(0,0),clk,clr,SelDir,ShEn,SelIn); MyFilterCell03: MyFilterCell PORT MAP ('0',s(0,N),'0',s(1,N+1),'0',s(0,N+1),clk,clr,SelDir,ShEn,SelIn); MyFilterCell30: MyFilterCell PORT MAP ('0','0',s(M,0),'0',s(M+1,1),s(M+1,0),clk,clr,SelDir,ShEn,SelIn); MyFilterCell33: MyFilterCell PORT MAP ('0',s(M+1,N),s(M,N+1),'0','0',s(M+1,N+1),clk,clr,SelDir,ShEn,SelIn); G1: for i in 1 to N GENERATE BEGIN Row0 : MyFilterCell PORT MAP ('0',s(0,i-1),'0',s(1,i),s(0,i+1),s(0,i),clk,clr,SelDir,ShEn,SelIn); END GENERATE G1; G2: for i in 1 to N GENERATE BEGIN Row3 : MyFilterCell PORT MAP ('0',s(M+1,i- 1),s(M,i),'0',s(M+1,i+1),s(M+1,i),clk,clr,SelDir,ShEn,SelIn); END GENERATE G2; G3: for i in 1 to M GENERATE BEGIN col0 : MyFilterCell PORT MAP ('0','0',s(i- 1,0),s(i+1,0),s(i,1),s(i,0),clk,clr,SelDir,ShEn,SelIn); END GENERATE G3; G4: for i in 1 to M GENERATE BEGIN col3 : MyFilterCell PORT MAP ('0',s(i,N),s(i- 1,N+1),s(i+1,N+1),'0',s(i,N+1),clk,clr,SelDir,ShEn,SelIn); END GENERATE G4; G5: for i in 1 to M GENERATE BEGIN G6: for j in 1 to N GENERATE BEGIN RowCol : MyFilterCell PORT MAP (Datain(i,j),s(i,j-1),s(i- 1,j),s(i+1,j),s(i,j+1),s(i,j),clk,clr,SelDir,ShEn,SelIn); END GENERATE G6; END GENERATE G5; END structural; Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 81

ANNEXE C: Simulation using ModelSim To get the work easy, takes 16 pixels and it makes the simulation. We will simulate the circuit design filterdesign_behavioral3.vhdl. Open the project MyFilterCell. C.1. Setting the project for simulation Some settings have to add to the project configuration in order that compiler creates the files allowing simulation with ModelSim_Altera. Assignments -> Settings... Select Simulation in the EDA Tool Settings list. In the Simulation Windows, select Tool name: Model_Sim-Altera Format for output netlist: VHDL Output directory: simulation/modelsim Click OK. C.2. Compile the project Processing -> Start compilation In addition to the file.sof (SRAM Object File) that will be used for programming the FPGA. The compiler generates also, in the folder MyFilterCell/simulation/modelsim, the Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 82

files.vho (VHDL Output File) and.sdo (Standard Delay Format Output File) that will be used by ModelSim for timing simulations. C.3. Generate (if necessary) the VHDL design entry. ModelSim needs a VHDL description (.vhd) of the design file. If it is not the case (as in this project where we have chosen a Block Diagram entry (.bdf)), a translation of the current entry in VHDL file has to be done: File -> Create/Update -> Create HDL File from Current File: VHDL C.4. Start ModelSim C.5. Edit the stimuli file The file filterdesign_behavioral.do describes the actions performed by the simulator. File -> New -> Source -> Do Save the file as filterdesign_behavioral.do This file contains: restart -f -nolist -nowave -nolog -nobreak -novirtuals -noassertions -nofcovers -noatv add wave clk add wave clr add wave start add wave ShEn add wave SelDir add wave SelIn add wave Datain0_0 add wave Datain0_1 add wave Datain0_2 add wave Datain0_3 add wave Datain1_0 add wave Datain1_1 add wave Datain1_2 add wave Datain1_3 Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 83

add wave Datain2_0 add wave Datain2_1 add wave Datain2_2 add wave Datain2_3 add wave Datain3_0 add wave Datain3_1 add wave Datain3_2 add wave Datain3_3 add wave Dataout0_0 add wave Dataout0_1 add wave Dataout0_2 add wave Dataout0_3 add wave Dataout1_0 add wave Dataout1_1 add wave Dataout1_2 add wave Dataout1_3 add wave Dataout2_0 add wave Dataout2_1 add wave Dataout2_2 add wave Dataout2_3 add wave Dataout3_0 add wave Dataout3_1 add wave Dataout3_2 add wave Dataout3_3 force clr 1 0ns,0 100ns force clk 0 0ns,1 100ns -r 200ns force Datain0_0 0 0ns,0 200ns,1 400ns,0 600ns force Datain0_1 0 0ns,0 200ns,1 400ns,0 600ns force Datain0_2 0 0ns,0 200ns,1 400ns,0 600ns force Datain0_3 0 0ns,0 200ns,1 400ns,0 600ns force Datain1_0 0 0ns,0 200ns,1 400ns,0 600ns force Datain1_1 0 0ns,0 200ns,1 400ns,0 600ns force Datain1_2 0 0ns,0 200ns,1 400ns,0 600ns force Datain1_3 0 0ns,0 200ns,1 400ns,0 600ns force Datain2_0 0 0ns,0 200ns,1 400ns,0 600ns force Datain2_1 0 0ns,0 200ns,1 400ns,0 600ns Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 84

force Datain2_2 0 0ns,0 200ns,1 400ns,0 600ns force Datain2_3 0 0ns,0 200ns,1 400ns,0 600ns force Datain3_0 0 0ns,0 200ns,1 400ns,0 600ns force Datain3_1 0 0ns,0 200ns,1 400ns,0 600ns force Datain3_2 0 0ns,0 200ns,1 400ns,0 600ns force Datain3_3 0 0ns,0 200ns,1 400ns,0 600ns force start 1 0ns run 15000ns WARNING!!! The file to be saved in the directory MyFilterCell for Functional Simulation and in the directory MyFilterCell/simulation/modelsim for Timing Simulation. C.6. Functional Simulation Functional simulation doesn t take into account the propagation delays into the FPGA. - Select the project directory: File -> Change Directory: C:/.../MyFilterCell - Create the working library: File -> New -> Library. Select a new library and a logical mapping to it. Type work in the Library Name Fields (if it isn t already entered automatically). - Compile the design unit Select the library work and the file MyFilterCell.vhd from the folder MyFilterCell. Click Compile, and then compile ControlUnit.vhd and filterdesign_behavioral.vhd. Click Done. ModelSim generates MyFilterCell, ControlUnit, filterdesing_behavioral into the library work. - Start the functional simulation Simulate -> Start Simulation In the design tab of the Start ModelSim window, select filterdesign_behavioral in the library work Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 85

Click OK An empty wave window appears: - Run the functiona simulation In the Tanscript windows (prompt VSIM >) type do filterdesign_behavioral ModelSim will run the simulation script defined number 5. Right click in the wave window, select Zoom Full to adjust the scale to the simualation time. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 86

Les diagrammes sont dans l ordre suivant : 1. HOST VI 2. FPGA VI ANNEXE D: Diagrammes Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 87

ANNEXE E: Moving Examples to another FPGA Target E.1. Overview Effectively extract FPGA examples from the example finder. When you install support for an FPGA target, the installation will include examples. The examples are configured for a specific target and are not necessarily configured for the target you are using. If the examples are configured for a different target, you can still use the examples by copying the items to a new project with a new FPGA target. In this tutorial, we are going to demonstrate this process using the example called Digital Line Output - crio.lvproj. If you want to use a different example, some of the steps will have to be modified for the example you are using. In this exercise, instructions have been added to help you implement this in another example. 1. Open the NI Example Finder by navigating to Help» Find Examples. 2. In the middle of the NI Example Finder window, navigate to Hardware Input and Output» CompactRIO»Basic IO. 3. Open Digital Line Output - crio.lvproj. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 88

4. In the following steps, we are going to add your crio to this example. a. Right-click Project: Digital Line Output - crio.lvproj which will open a menu b. Navigate to New» Targets and Devices... Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 89

c. At this point, the Add Targets and Devices on Digital Line Output - crio.lvproj. Under the Real-Time CompactRIO folder, select your crio. In this example, ReCon-9072-CptPlant will be selected. d. After you selected your target, select OK. Now your target should be added to your target. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 90

5. Now that we have created the new target, we need to move over the VIs and the physical channels used in this example. If you aren't using this example, the steps to change the physical channels will be slightly different depending upon the hardware and example used. Like stated above, there will be extra instructions to account for this. a. Expand both CompactRIO targets, Chassis, and FPGA Targets like shown below. b. Under the Items to Move folder, Select Digital Line Output.vi and drag it to Mod3 like shown in the picture below. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 91

Note: If you are using a different example, there will be VI or VIs under the folder called Items to Move. Select them and drag them under the module folder like in this exercise. c. Now that we have moved the VI, we need to change the names of the Digital Output ports. In this example, it uses four digital lines (DO0, DO1, DO2, and DO3) so we need to rename the digital lines in our module to match. Right-click Mod3/DO0 and select Rename. Type DO0. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 92

Note: If you aren't using this example, look at the channels used by your example and rename the channels accordingly. For example, if Digital input channels were used with the names DI0, DI1, DI2, and DI3, find the Digital Input channels in your CompactRIO and rename them. d. Repeat step 3 until all Digital Output lines have been renamed like shown below: 6. Now that we moved the VI and changes the channel names, remove the original target by clicking the old target and press Delete. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 93

7. Recompile the FPGA VI by right-clicking the FPGA VI and selecting Compile. 8. After the compile has started, the LabVIEW FPGA Compile Server will open stating the status of the compile. When Server Status says Idle, click Stop Server. 9. After clicking Stop Server, the Compilation Status window will state if the compile was successful. Click Close if it was successful. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 94

10. If the program includes a host VI, you must update the Open FPGA VI references. To update the references, right-click the Open FPGA VI Reference function, choose Configure Open FPGA VI Reference from the shortcut menu, and navigate to the FPGA VI in the new target 11. Now that we have completely moved over the example, we need to save all the files in a new directory so we can modify them. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 95

a. Navigate File» Save as.. b. In the Save as.. window, select Copy and click Continue... c. Save the project in a different location on your machine. d. For the VIs in the project, perform the same steps inside the VI and save them in the same location as the project. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 96

12. Now you have completed extracting the FPGA Examples from the example finder. You can now modify this example for your application without affect the original copies. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 97

ANNEXE F: Importing External IP Into LabVIEW FPGA F.1. Introduction to the CLIP Node The CLIP Node is a framework for importing existing FPGA IP into LabVIEW FPGA hardware and communicating to it through the LabVIEW FPGA diagram. Once imported, the IP runs independently and in parallel with LabVIEW FPGA execution. The IP can be in the form of either raw VHDL or intermediate files such as electronic design interchange format (EDIF) netlists. This feature targets users with some digital design experience and basic knowledge of VHDL, because the IP imported is often lower-level hardware description language ( HDL ). Support for CLIP varies by FPGA target. Refer to the target hardware documentation for information about CLIP support. Some FPGA targets work with one or both of the following types of CLIP: User-defined CLIP Import VHDL code to communicate directly with an FPGA VI. Socketed CLIP Import VHDL code to communicate directly with an FPGA VI and with FPGA pins that are not exposed to the LabVIEW FPGA Module. Some FPGA targets define a fixed-clip socket in the FPGA where you can insert socketed CLIP. Figure E.1. Imported VHDL code in user-defined CLIP Nodes can communicate with an FPGA VI, whereas a socketed CLIP Node allows the IPinterface with both the FPGA VI and available FPGA pins. For the most up-to-date information, refer to the LabVIEW FPGA Module Help topic titled Using VHDL Code as Component-Level IP (FPGA Module). F.2. Using CLIP in an FPGA Application The following steps outline the procedure for using CLIP in an FPGA application: 1. Create or acquire the IP. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 98

2. Declare the CLIP and define the IP interface in the properties of an FPGA target. 3. Add CLIP items to the project. 4. Use the CLIP items in an FPGA VI. F.2.1. Create or Acquire the IP To add CLIP to an FPGA target, you must provide IP in the form of VHDL code to compile into the FPGA target. You can provide the VHDL code in the following ways: o o o Create VHDL. Take advantage of other HDLs such as Verilog by using the Xilinx CORE Generator to create your own compatible cores. Purchase IP from Xilinx or partners. Note: More than 50 Xilinx IP blocks are in the CORE Generator IP palette in LabVIEW FPGA, which you can incorporate into the dataflow of your LabVIEW FPGA VI without the need to import it using the CLIP or IP Integration Node. Learn how to Increase IP Reuse With the Xilinx CORE Generator IP Palette. An important consideration when using CLIP Nodes is the data types supported in LabVIEW FPGA and how they translate to VHDL data types. If your IP uses a logic vector that is not one of the data types listed in Table 1, you need to write a VHDL wrapper to extend, cut off, or break up the standard LabVIEW types to fit the data widths of the IP. Refer to the LabVIEW FPGA Module Help to learn more about other considerations for your IP including using external clocks, crossing clock domains, using synchronization registers, implementing asynchronous resets, and working with constraints and hierarchy. Table F.1. Data types that are supported for use in the CLIP interface Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 99

F.2.2. Declare the CLIP and Define the IP Interface in the Properties of an FPGA Target Note: The following example uses the attached simple _and.vhd file to demonstrate how to import IP into a user-defined CLIP Node. To map the IP inputs and outputs to I/O in LabVIEW, use the FPGA Target Properties Wizard to create an XML file that defines the necessary characteristics of the IP. Follow the steps below to complete this task. 1. Create a new LabVIEW project with an FPGA target. Right-click the FPGA target and select Properties. The Properties dialog contains a section labeled Component-Level IP. Click the Create File button to create the XML file. Figure F.2. Click Create File to begin defining the declaration XML file. 2. Click the Add Synthesis File button and browse to the VHDL file that represents the top-level component IP, simple_and.vhd in this case. Proceed by clicking Next>. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 100

Figure F.3. After adding your IP s synthesis file, click Next>. 3. remainder of the wizard configures the declaration XML file. In this example, navigate the rest of the wizard with the defaults by clicking Next>, validate the Syntax of the imported file, and then click through the remaining Next> buttons. Figure F.4. The generated XML declaration file from the wizard should be listed for the imported IP block. Once you have finished the Configuring CLIP Wizard, the CLIP declaration name (defined in the XML file) appears alongside the path of the file. In this dialog, you can declare multiple CLIP Nodes for all the different IP blocks you need to import. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 101

F.2.3. Add a CLIP Item to a LabVIEW Project Declaring the CLIP within the FPGA does not actually add it to the project because you can instantiate multiple instances of one CLIP on the same FPGA. In the next step, you will create an instance of the previously declared simpleand CLIP item. 1. Right-click the FPGA target and select New»Component-Level IP. In the CLIP dialog that appears, select the desired CLIP, give this instance a unique name, and select clocks to connect to any lines in the CLIP with the Clock signal type. In this example, the latter two options are left as defaults. Figure F.5. This dialog appears when you add an instance of a CLIP to the project. Select the CLIP, define a name, and configure clocks. 2. Once you click OK from this dialog, this CLIP and all associated inputs and outputs show up in the project in an entry labeled with the instance name. Figure F.6. This is the project after adding the CLIP, showing all of the I/O point for the IP. F.2.4. Pass Data between the CLIP and an FPGA VI At this point, you are ready to communicate between the CLIP and the FPGA VI. To do so, simply drag and drop the desired I/O point from the project to the FPGA diagram. Your IP should have documentation on how to use the IP. For instance, many IP blocks use some type of handshaking lines for passing data in and out. These are typically Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 102

labeled data valid or enable. Use LabVIEW logic to send the correct values at the correct times to exercise the IP. You can place CLIP I/O inside or outside a single-cycle Timed Loop (SCTL), but keep in mind that inside an SCTL, you might have to consider clock domain crossings and use synchronization registers. Figure F.7. To communicate with the CLIP from LabVIEW FPGA, drag and drop the IP inputs and outputs from the project window to the block diagram of the FPGA VI. Figure F.8. The complete LabVIEW FPGA block diagram communicates with IP imported using the CLIP. Projet de fin d études Effectué, de Mars à Juillet 2012 Mahmoud ZAKARIA Page 103