Cr�ation de la plarte forme ML310 et int�gration du composant by 8c9j6S4

VIEWS: 6 PAGES: 52

									                      Créer sa première IP sur la ML310
Introduction.


Utilisation de l'outil xilinx Create Import Peripheral Wizard. Cet outil sert à créer le squelette
de l’architecture de notre IP.Il va nous permettre d'accomplir les phases suivantes.

       Créer le squelette de notre composante en HDL.
       Créer les liaisons entre le bus et notre composante en HDL.
       Générer automatiquement une plate-forme de simulation avec l'outil BFM de l’EDK.
       Générer les drivers C pour l’interfaçage logiciel de notre composante.
       Optionnellement générer les fichiers pour la synthèse de l’IP avec ISE/XST.
       Créer l'architecture des répertoires et l’arborescence des fichiers de l’IP.

Objectif

       Comprendre la structure des répertoires du logiciel EDK.
       Générer l’IP rattachée au bus en utilisant l'outil Create Import Peripheral Wizard.
       Effectuez une simulation BFM via EDK.
       Écrire les drivers logiciels pour notre composante.
       Construire la plate-forme du système pour le tester sur la carte.

Description du logiciel EDK.


Le logiciel xilinx Embedded Development Kit (EDK), est fourni avec un grand nombre de
composants configurables. Un grand nombre de systèmes existant peut être créé avec cet
outil, mais la fonction la plus intéressante est la création de ses propres composants.

La génération des composants se fait automatiquement par le logiciel, il n'y a cependant
quelques règles à respecter.
        Notre composant doit être attachés à un bus d’interface pour fonctionner avec le
processeur. Les bus compatibles entre le processeur et l’IP sont OPB, PLB, FSL, notre
architecture devra donc être compatible avec ces bus. (Voir figure)
        Pour être reconnu par le logiciel notre composant avoir une architecture de répertoire
spécifique. (Voir figure)




       EDK utilise la librairie d'interfaçage de propriété intellectuelle IPIF. Cette librairie
permet de générer la logique entre le bus d’interface et notre composant. Elle peut être
paramétrées de façon à générer des registres, des signaux d'interruption, des canaux DMA…
Elle permet surtout de ne pas réinventer ce qui existe déjà.




       Pour générer correctement le composant nous devons respecter les choses suivantes
dans notre flot de conception.
       Définir les interfaces : identifier sur quel bus on veut connecter notre composant.
       Implémentation et vérification de la fonctionnalité : il faut apprendre à utiliser les
composants déjà existants dans les librairies. Si l'on a développé son propre composants il est
préférable de le vérifier et de le simuler seul, avant de le connecter au bus.
       L'importer dans le logiciel EDK : il faut que la structure des répertoires de notre
composant soit reconnue par le logiciel EDK.

Structure des composants générés par le logiciel :
       Génère les fichiers synthétisable en VHDL ou Verilog : l'outil génère
automatiquement le fichier HDL. Pour les périphériques OPB/PLB nous avons deux fichiers
HDL, qui sont le top-level et le user-logic. Ces fichiers peuvent être soit en VHDL , Verilog
ou alors un mixage des deux. Les fichiers décrivant notre composant seront rattachés au user-
logic.

       L'outil permet de s'affranchir de la complexité du protocole des bus :

       Configurer le module IPIF : l'outil génère le module IPIF dans le fichier top-level. On
peut paramétrer dans ce module la logique que l'on veut utiliser par exemple : des registres,
des FIFO, des registres d'interruption, des canaux DMA, etc.

        Générer la plate-forme de simulation BFM : optionnellement l'outil peut générer les
fichiers de simulation pour tester notre composant.

       Générer les fichiers de paramétrage : optionnellement l'outil peut générer les fichiers
de paramétrage si l'on souhaite utiliser les logiciels ISE ou XST.

        Générer les drivers logiciels : optionnellement l'outil peut générer les drivers en
langage C pour le composant. L'utilisateur devra insérer dans les fichiers générés le code pour
tester et utiliser son composant avec la plate-forme.

        Créer la structure des répertoires : l'outil crée une structure de répertoires compatibles
avec le logiciel EDK. Cette structure est compatible avec les autres logiciels xilinx. Voir
figure.




Flot de conception du logiciel EDK.
Résumé du flot de création de la plate-forme système et de son composant :
      1) Utiliser l'option Base System Builder (BPS) du logiciel XPS pour générer la plate-
forme mono processeur que l'on va utiliser avec son composants.

      2) Utiliser l'outil Creat and Import Periferal Wizard en mode création pour générer, le
HDL, la plate-forme de simulation BFM et les fichiers nécessaires au logiciel ISE.

         3) Utiliser le logiciel ISE pour ouvrir et modifier le projet créé précédemment. C'est
avec ce logiciel que l'on va intégrer notre code au périphérique généré. Notre code sera inséré
dans le fichier user_logic.vhd. Le code inséré aura préalablement été synthétisé et simulé par
l'utilisateur.

       4) Utiliser l'outil Creat and Import Periferal Wizard en mode importations pour que
les modifications effectuées par l'utilisateur puissent être prises en compte. Pendant cette
phase le logiciel effectue un trst de syntaxe sur les fichiers VHDL ou verilog. Il vérifie aussi
que tous les fichiers nécessaires au bon fonctionnement de l’IP soient présents.

        5) Utiliser le logiciel XPS pour intégrer à la plate-forme mono processeur généré à
l’étape 1, le composant importé à l'étape 4.

       6) Générer le fichier à télécharger dans le FPGA avec XPS.

       7) Utiliser le logiciel XPS pour développer le logiciel de l'application de la plate-forme
mono processeur. XPS inclus aussi des outils de déboguage pour optimiser le code
exécutable.
       Création d'une plate-forme mono processeur et d’un composant.



Dans cet exemple la plate-forme mono processeur va contenir les composants matériels
suivant :
        Le processeur : Un power PC405
        Des blocs de mémoire pour stocker l'application.
        L’IP du bus PLB
        L’IP du bridge entre le bus PLB et le bus OPB.
        L’IP du bus OPB sur lequel doit être rattaché notre composant.
        L’IP JTAG pour programmer le FPGA.
        L’IP DCM pour générer les horloges nécessaires à la plate-forme.
        L’IP RS232 pour avoir une console de dialoguer avec l'extérieur.
        L’IP de notre composant.
Cette structure va nous permettre de tester notre IP. L'application logicielle va s'exécuter sur
le processeur et les données seront sorties sur la fenêtre terminale par l'intermédiaire de la
liaisonRS232.


Nous allons maintenant voir comment créer la plate-forme mono processeur à l'aide de l'outil
de création Xilinx Platform Studio.
Création de la plate-forme processeur.


       1) Ouvrir le logiciel XPS, choisir dans la boîte de dialogue Base system Builder et
          cliquez sur OK pour démarrer BSB, voir figure.




        Après avoir cliqué sur OK indiquer le chemin sera enregistré le projet.
        (Ce logiciel est basé sur un noyau linux exécuté sous WINDOWS, les espaces et
certains caractères sont donc à proscrire dans les noms de fichier et de répertoires).
        Par exemple entrer c:\CreatPlat :
        Cliquez sur OK.




Le logiciel doit prendre quelques minutes pour créer le projet. Une nouvelle fenêtre va
apparaître à l'écran cliquez sur NEXT.
La fenêtre suivante nous invite à choisir la plate-forme cible sur laquelle nous allons
implanter nos composant. Nous allons devoir choisir le fabricant de la carte, le nom de la
carte et sa version.
        Le fabricant de la carte est Xilinx.
        Le nom de la carte est ML310.
        L'indice de révision est D.
Cliquez sur NEXT.
La fenêtre nous invite maintenant à sélectionner le type de processeur. Voir figure
       Sélectionnez le processeur PowerPC.
       Cliquez sur NEXT.
Nous allons maintenant configurer le processeur.
        Il est préférable de garder dans un premier temps les options par défaut proposé par le
logiciel.
        Nous avons juste rajouté la mémoire nécessaire à l'exécution du logiciel.
                 Sélectionnez pour On-Chip Memory (OCM) Data : 16KB
                 Sélectionnez pour On-Chip Memory (OCM) Instruction : 16KB
        Cliquez sur NeXT.




         Vous devez vous assurer d'avoir assez de mémoire pour exécuter votre application sur
le processeur, tout en gardant à l'esprit que d'autres périphériques peuvent aussi utiliser les
blocs RAM. Dans le FPGA XC2VP30 ils sont au nombre de 136. Une autre alternative serait
d'utiliser la mémoire DDR en cas de saturation du nom de BRAM.
        Les fenêtres suivantes vont nous permettre de choisir les bus et les périphériques
d'entrée sortie qui vont être rattachées processeur.
        Nous avons sélectionné l'interface d'entrée sortie RS232_Uart et désélectionner tous
les autres modules. Voir figure.
        Cliquez sur NEXT.
       Vous pouvez obtenir des informations sur la configuration des périphériques en
cliquant sur le bouton More Info. Si vous voulez des informations plus détaillées sur les
périphériques cliquez sur les boutons Data Sheet.

       Dans la fenêtre suivante des sélectionner tous les périphériques.
       Cliquez sur NEXT.
      Dans la fenêtre suivante Add Internal Peripheral garder les options par défaut, cliquez
sur NeXT.
        Nous avons maintenant à l'écran la fenêtre de configuration logicielle. Elle nous
permet de sélectionner le périphérique d'entrée sortie de dialogue entre la carte ML310 et le
PC qui est la liaison RS232. Les autres options permettent de créer les applications de tests de
la mémoire et des périphériques d'entrée sortie qui ont été ajoutées précédemment. Nous
allons garder les options par défaut. Cliquez sur NEXT. Voir figure.
        Les fenêtres suivantes résument la configuration que nous venons d'effectuer. Un
certain nombre d'options ont été affecté par défaut elles pourront être modifiées par la suite.
Cliquez sur Generate et ensuite sur Finish.
        Le logiciel vous informe que le projet a été créé avec succès. Dans la fenêtre suivante
sélectionnez Start Using Platform Studio et cliquez sur OK.
        La plate-forme mono processeur a été générée correctement. Dans les options choisies
précédemment nous avons laissé le logiciel XPS générer les fichiers pour un test basique de la
carte. Nous pouvons pour tester notre application synthétiser et implanter l'architecture
matérielle puis compiler les logiciels de tests à fin de s'assurer du bon fonctionnement de la
plate-forme mono processeur.
        Nous devons nous assurer que la carte ML310 est correctement connectée au PC.
C'est-à-dire que les câbles JTAG et série sont connectés, le premier sur le port parallèle, le
second sur le port série.
        Démarrer le logiciel HyperTerminal de Windows. Et le configurer comme suivant.
               Com1
               9600 Bauds
               8 bits de données
               Pas de parité
               1 bit de stop
               Pas de Flow de contrôle

       Mettre sous tension la carte ML310.

        Dans le menu du logiciel XPS sélectionnez Tools -> Download. Le logiciel va générer
la plate-forme matérielle et compiler les applications logicielles. Il va ensuite les télécharger
dans FPGA. Cette action demande une vingtaine de minutes. Une fois le téléchargement du
fichier dans le FPGA effectué on voie s'afficher sur la fenêtre du logiciel HyperTerminal le
résultat des tests. Voir figure
      Nous avons constaté le bon fonctionnement de la plate-forme, nous pouvons donc
maintenant intégrer notre composant. Retournons dans la fenêtre principale du logiciel XPS.
Création de notre composant.

       Dans cette partie nous allons voir comment créer le squelette de l'architecture de notre
composant. Il va de soi que le code que l'on va ajouter a été préalablement synthétisé et
simulé. Nous allons créer un composant qui va avoir les caractéristiques suivantes :
       Il sera connecté sur le bus OPB.
       Nous aurons cinq registres de 32 bits. Deux en entrée et trois en sortie.
       Une entrée d'horloge et une entrée reset.

       1) Dans le menu du logiciel un XPS, sélectionnez Tools -> Creat/Import Peripheral…
       Cliquez sur NEXT pour continuer.




        Le logiciel est capable de générer quatre types de périphériques basés sur le bus IBM
CoreConnect. En utilisant les périphériques prédéfinis de la librairie IPIF l'utilisateur peut
ainsi réduire son temps de développement « Time to Market ». Le logiciel peut créer cinq
configurations de bus différentes :
        OPB Slave-only : le périphérique est connecté en esclave sur le bus.
        OPB Master-Slave : le périphérique pourra devenir maître ou esclave selon
l'application.
        PLB Slave-only : le périphérique est connecté en esclave sur le bus.
        PLB Master-Slave : le périphérique pourra devenir maître ou esclave selon
l'application.
        FSL Master-Slave : le périphérique pourra devenir maître ou esclave selon
l'application.

       En cliquant sur les liens en bleu nous avons une informations détaillées sur chaque
type de bus.
2) Dans la fenêtre sélectionnez Creat Template for a new peripheral.
Cliquez sur NEXT.
        3) Ensuite il faut choisir où l'on voulons créer et le nouveau composant. Soit nous le
créons dans un répertoire spécifique où sont regroupés tous nos composant ou alors on peut
l'intégrer au projet en cours. Si on choisit la dernière solution le composant ne sera pas visible
dans les nouveaux projets que nous avons créés. Pour notre exemple nous allons le créer dans
le répertoire de projet.
        Cliquez sur suivant.




       4) Ensuite nous devons donner un nom à notre composant. Nous avons la possibilité
de spécifier un numéro de version en fonction des évolutions que l'on effectuera sur le projet.
5) nous allons maintenant configurer le type de bus que nous vous non utiliser.

Nous connecterons notre composant sur le bus OPB.
      6) Configuration de l'interface IPIF.
      Pour faciliter le développement du composant la librairie propose plusieurs
implémentations. Nous pouvons choisir d'implémenter :
      Une gestion du reset en entrée en sortie.
      Un système de gestion du bus.
      Un ou plusieurs canaux DMA.
      Un contrôleur d'interruptions.
      Un ou plusieurs registres en entrée sortie paramétrable de 8 à 32 bits.
      D'implémenter la logique permettre en de piloter le bus en maître.
      D'implémenter la logique d'un contrôleur d'adresse.

        Notre composant nécessite juste d'avoir une gestion du reset en entrée et quelques
registres de 32 bits.
       7) Choix de la taille et du nombre de registres.
       Notre composant a besoin de cinq registres de 32 bits chacun. Le logiciel les créés par
défaut en entrée sortie. Il faudra par la suite modifiée le code VHDL du fichier User-Logic
pour spécifier les registres qui seront en entrée et ceux qui seront en sortie.
        8) choix des signaux de contrôle de la librairie IP Interconnect (IPIC).
        Pour notre composant nous garderons les choix prédéfinis. En cliquant sur chaque port
le logiciel donne une description sommaire des différents signaux. Le nombre des cases
cochées dépend de la configuration choisie au point 6.




        9) Le logiciel génère optionnellement les fichiers pour l'implémentation matérielle et
logicielle du composant. L'utilisateur a le choix de créer le fichier user-logic et les drivers
pour l'implémentation du logiciel par l'outil Creat and Import Peripheral. On peut aussi choisir
de générer le fichier user-logic en Verilog au lieu du VHDL. Il est conseillé pour les
premières utilisations de générer les projets pour les logiciels ISE et XPS.
       La génération de la logique de gestion de notre composant est maintenant terminée. Il
nous reste encore à incorporer notre code VHDL au fichier user_logic.vhd.




        Le logiciel a créé à la racine de notre projet de répertoire supplémentaire. Le répertoire
drivers contient les primitives en langage C de notre composant. Le répertoire pcore contient
l'arborescence des dossiers et fichiers de notre composant.
L'implémentation de notre code dans le fichier user_logic.vhd.

       Nous avons ajouté notre code VHDL dans le fichier user_logic.vhd avec le logiciel
ISE. Pour lancer ISE il faut nous le cliquer sur le fichier
C:\CreatPlat\pcore\JpegEtBuf_v1_00_a\devl\projnav\JpegEtBuf.npl.
       Dans la fenêtre source du projet nous voyons que notre composant est une librairie.
Dans la soue librairie JpegEtBuf_v1_00_a se trouvent les fichiers modifiés.




       Le composant JPEG que l'on va insérer à l'arborescence suivante.




        La description détaillée du composant JPEG sera traitée dans une autre partie. Il est
conseillé de bien hiérarchiser la description de ces composants. Le fait de les décrire en
module et sous module rendra les modifications et la maintenance beaucoup plus aisée. Le
composant que nous allons ajouter aux fichiers user_logic.vhd sera vu comme une « Black
box ». Il se composera exclusivement des registres et de deux signaux reset et clock. Nous
intégrons aussi un diviseur de fréquence pour passer d'une fréquence de bus de 100Mhz à une
fréquence de 20MHz qui est la fréquence d'utilisation de notre composant. Voir figure.
       Contenu du fichier user_logic.vhd.

       Le fichier user_logic.vhd est très bien documenté. Xilinx a pris le soin d'indiquer à
quels endroits l'utilisateur pouvait insérer son code.
       A la ligne 68 insertion des librairies.
       A la ligne 94 insertion des paramètres génériques de l'entité.
       A la ligne 106 insertion des ports sortant de l'IP.
       A la ligne 133 insertion des composants et déclaration des signaux.
       A la ligne 151 insertion de la logiques.
       À partir de la ligne 153 xilinx donne un exemple de code permettant de lire et écrire
dans les registres. Ce code est constitué de trois parties nous avons :
       De la ligne 171 à la ligne 174 la connexion entre les signaux de commandes venant du
bus OPB et les signaux commandant nos registres.
       De la ligne 176 à la ligne 224 un processus qui va gérer l’écriture dans les 5 registres
des données venant du bus OPB. Ce processus initialise aussi les registres à une valeur
prédéfinie lors du reset.
       Après la ligne 225 un processus qui lit les données contenues dans les registres pour
les envoyer sur le bus OPB.


       Modification du fichier user_logic.vhd.

        Nous allons maintenant modifier le fichier user_logic.vhd. Nous allons commencer par
insérer la déclaration du composant et des signaux après la ligne 133.
      Après nous allons connecter les signaux provenant de l'IP avec ceux de notre
composant. Puis nous allons déclarer notre composant.
Ensuite nous allons ajouter le diviseur de fréquence.
         Il ne reste plus qu'à modifier le process d'écriture dans les registres pour empêcher
l'écriture dans les registres en lecture seule.
        Une fois ces opérations effectuées il faut enregistrer le projet et lancer l'outil Check
syntax pour vérifier s'il n'y a pas eu d'erreur de frappe.
        Il faut maintenant ajouter les autres fichiers VHDL faisant partie de notre composant.
Les fichiers qui ne sont pas du VHDL ne sont pas visibles dans l'onglet Module View mais
dans l'onglet Library View.
       La synthèse de la librairie de notre IP confirmera qu'il n'y a pas d'erreur de syntaxe.




       Le composant est maintenant fonctionnel. Mais comme nous avons modifié le fichier
user_logic.vhd nous devons relancer le logiciel Create and Import Peripheral en mode
importations de composants pour réactualiser les fichiers .mpd/.pao nécessaire au logiciel
XPS.
          1) Lancer le logiciel Create and Import Peripheral. Choisir Import existing peripheral.




          2) Choisir d'importer le composant depuis un projet existant. Indiquer le chemin du
projet.




       3) Renseignez correctement les cases avec le nom du composant et son numéro de
version.
        4) nous devons maintenant indiquer au logiciel les fichiers présents dans notre
architecture. Le composant est constitué des fichiers VHDL et de fichiers Netlist. Les fichiers
Netlist proviennent des primitives xilinx utilisés pour générer les tables, les mémoires et la
DCT touche à la ligne.




      5) dans le panneau HDL Source Files :
             Comme nous importons le fichier il faut sélectionner Use existing Peripheral
Analysis Order File (*.pao).
             Indiquer le chemin du fichier pao qui a été créé précédemment.
        6) La fenêtre HDL Analysis Information.
                Avec cette boîte de dialogue nous indiquons au logiciel les librairies et les
fichiers VHDL nécessaires à la compilation de notre périphérique. À l'aide de la commande
Add Files nous devons indiquer les fichiers VHDL à ajouter. Nous ajouterons les fichiers
compressor.vhd et head.vhd.




                Pour faciliter la synthèse du composant les fichiers VHDL doivent avoir un
ordre particulier. Ils doivent être classés du module le moins important au module le plus
important pour respecter la hiérarchie. Pour changer la hiérarchie dans les fichiers VHDL il
suffit de sélectionner un fichier et d'utiliser Move Up ou Move Down.
               Lorsque l'on clique sur suivant, le logiciel effectue une vérification syntaxique
des fichiers VHDL insérés. En cas d'erreur il faudra retourner dans le logiciel ISE pour
corriger le problème.

       7) Dans la fenêtre Bus interface, ont choisi le type de bus dans notre cas OPB en
esclave.




       8) cliquez sur suivant jusqu'à atteindre la fenêtre Identify Interrupt Signal, choisir No
Interrupt. Continuez à cliquer sur suivant jusqu'à la fenêtre Netlist Files. Dans cette boîte de
dialogue nous devons indiquer les fichiers Netlist à intégrer à notre composant.
        9) une boîte de dialogue nous indique le composant a été correctement générée. On
peut consulter le résumé de l'opération dans le milieu de la fenêtre. On n'y retrouve les
fichiers insérés ainsi que les sous répertoire de l'architecture du composant.




        Le composant a été correctement généré, nous pouvons maintenant retourner sous le
logiciel XPS pour l'intégrer à notre plate-forme mono processeur.

Ajout du composant JPEG à la plate-forme mono processeur.

        Ouvrir le projet c:\CreatPlat\system.xmp avec le logiciel XPS. Nous allons maintenant
ajouter le composant JPEG à la plate-forme mono processeur. Dans les menus sélectionnés
Project -> Add/Edit Cores… Dans la fenêtre de droite choisir le composant JpegEtBuf et
cliquez sur Add, le composant apparaît maintenant dans la fenêtre de gauche.




        Cliquez sur l'onglet Bus Connections. Cette boîte de dialogue va nous permettre de
connecter le composant JPEG aux bus OPB en esclave. Cliquez dans le carré correspondant à
la jointure de la ligne JpegEtBuf et de la colonne OPB, un S grisé doit apparaître.
        Après avoir sélectionné le bus OPB en esclave cliquez sur appliquer. Cliquez ensuite
sur l'onglet Addresses. Cette fenêtre va nous permettre de paramétrer la carte des adresses
matérielles de la plate-forme mono processeur. Plusieurs possibilités s'offrent à nous :
        Soit l'utilisateur modifie les adresses qu'il veut changer (réserver aux utilisateurs
avertis).
        Soit l'utilisateur utilise le bouton Generate Addresses. Dans ce cas le programme
réaffecte tout l'adressage mémoire et prend en compte les composants ajoutés.
        La dernière possibilité est un compromis entre l'adressage automatique et l'adressage
manuel. On va bloquer les adresses déjà choisies et on va générer seulement les adresses pour
notre composant. Cette méthode permet de garder la compatibilité de l'adressage quand nous
allons développer le logiciel. En effet si l'on garde les mêmes plages d'adresse pour toute les
plate-forme mono processeur générer, ne seront pas obligés de re- développé le logiciel.
        On coche donc toutes les cases de la colonne Lock sauf celles concernant notre
composant. On clique ensuite sur la touche Generate Adresses. Le logiciel XPS affecte pour
notre composant une plage mémoire sur les instances plb2opb sur un des quatre préfixes
RNG0 à RNG3. On doit juste vérifier que la plage d'adressage de notre composant est incluse
dans les plages de préfixes.
       Cliquez sur appliquer.

        On sélectionne maintenant l'onglet Ports. Cette fenêtre va nous permettre de connecter
les ports de notre IP. Pour notre composant le seul port connectable est l’OPB_Clk qui
correspond à l'entrée d'horloge du composant. Dans la fenêtre de droite ont recherche le
composant JpegEtBuf on sélectionne le port OPB_Clk, on clique sur la touche <<Add. Après
dans la colonne Net Name en modifie la valeur sys_clk en sys_clk_s pour connecter l'entrée
d'horloge de notre IP à l'horloge système.
        Cliquez sur la touche appliquer. La plate-forme mono processeur est maintenant
configurée correctement cliquer sur OK pour terminer. Dans la fenêtre de gauche système du
logiciel XPS double cliquez sur le fichier system.mhs FPGA vérifier que le composant
JpegEtBuf a bien été ajouté avec les bons paramètres.




       Compilation du fichier à télécharger dans FPGA.

        Pour générer le bitstream à télécharger dans le FPGA il suffit de sélectionner dans le
menu Tools ->Update Bitstream. Le problème c'est que pour une raison indéterminée le
logiciel de synthèse XST de Xilinx n'arrive pas à synthétiser correctement le code VHDL du
composant JPEG. Par contre le logiciel de synthèse Synplify du fabricant Synplicity génère le
code correctement. Malheureusement le logiciel Synplify n'est pas directement compatible
avec le logiciel XST. Nous sommes obligés de passer par le logiciel ISE pour pouvoir
effectuer la synthèse de la plate-forme mono processeur.

       Exportation de la plate-forme mono processeur du logiciel XPS vers le logiciel ISE.
        Théoriquement l'exportation d'un projet du logiciel XPS vers le logiciel ISE ne doit
pas poser de problèmes. Mais la réalité est toute autre. L'exportation se fait par l'intermédiaire
de fichier script. Nous avons constaté un grand nombre d'erreurs lors de la génération des
projets. Nous avons testé plusieurs versions du logiciel XPS de la 6.3 à la 7.1 mais aucune des
versions mêmes avec les dernières mises à jour n'a été capable d'arriver au résultat souhaité.
        La plupart des fichiers générés pour créer les projets sont les fichiers texte. La solution
retenue est de générer le projet en automatique avec le logiciel XPS. Pour chaque erreur ont
modifie les fichiers texte à la main jusqu'à arriver au résultat souhaité.

       Exportation du projet XPS vers le logiciel ISE.

        Dans le menu du logiciel XPS choisir Options -> Project Options onglet Hierarchy and
Flow. Dans le menu déroulant Synthesis Tool for Non-Xilinx IPs choisir None. Dans la case à
cocher Implementation Tool Flow choisir ISE (ProjNav). Dans l'onglet HDL and simulation
choisir la case à cocher VHDL.




        Maintenant que nous avons choisi d'exporter le projet vert logiciel ISE à fin de
synthétiser la plate-forme mono processeur avec le logiciel Synplify, il reste une petite
modification à apporter dans le fichier JpegEtBuf_v2_1_0.mpd qui se trouve dans le
répertoire c:\CreatPlat\pcores\ JpegEtBuf_v1_00_a\data. Dans ce fichier nous allons modifier
les options pour que le logiciel XPS ne synthétise pas le composant JPEG avec le logiciel
XST. Dans le fichier mpd ont modifie l'option OPTION IMP_NETLIST = TRUE en OPTION
IMP_NETLIST = FALSE. Le logiciel XPS, lors de l'exportation, va synthétiser chaque IP de
la plate-forme mono processeur avec les logiciels de synthèse xilinx XST. Pour notre
composant JPEG il va se contenter d'ajouter au projet ISE, les fichiers VHDL, les librairies et
les fichiers NetList.
        Le problème c'est que le logiciel XPS ne peut pas générer correctement le projet pour
logiciel ISE. Dans un premier temps on exporte le projet XPS sous le logiciel ISE par la
commande Export to ProjNav dans le menu Tools. On constate que pour logiciel XPS tout se
passe correctement. On ouvre le fichier system.ise dans le répertoire c:\CreatPlat\projnav. On
constate que la structure de notre plate-forme a été correctement générée mais notre
composant JPEG est vide.




         Une solution serait d'aller chercher tous les fichiers un par un pour reconstruire
l'architecture du composant JPEG. Le problème c'est que les fichiers qui constituent les
librairies doivent être inséré dans un ordre précis ce qui rend sa démarche longue et
fastidieuse.
         Une autre solution est de copier le projet générer dans un autre répertoire pour l'utiliser
par la suite. On copie le répertoire contenant le projet ISE c:\CreatPlat\projnav dans le
répertoire c:\CreatPlat\projnav_VHDL. Dans ce répertoire on copie le fichier
c:\CreatPlat\ise_cmdfile que l'on renomme ise_cmdfile_VHDL. On copie ensuite dans ce
répertoire les fichiers system.ucf, system.bmm, system.vhd, jprgrtbuf_0_wrapper.vhd et le
répertoire c:\CreatPlat\implementation.




       Maintenant on retourne dans le logiciel XPS. Dans le menu Options on sélectionne
Project Options. Dans l'onglet HDL and Simulation ont choisi la case à cocher Verilog.




       On lance l'exportation vers ISE par la commande Tools -> Export to ProjNav.

        Le projet généré sera en Verilog. Une partie de nos fichiers est en VHDL ce qui va
poser beaucoup de problèmes avec le logiciel Symplify. L'intérêt de cette manipulation est
que le logiciel XPS génère correctement les librairies à inclure dans le logiciel ISE. Nous
constatons d'ailleurs que le logiciel XPS n'arrive pas à générer le projet correctement. Nous
avons l'erreur suivante.
        En cherchant dans la fenêtre on identifie la commande qui pose problème.




        En ouvrant le fichier ise_cmdfile on constate que le script a inséré des lignes parasites.
Il veut en effet ajouter des librairies vides au projet ISE.




        Il faut supprimer les couples de lignes suivants :

AddSource(vhdl, VHDL Design File)
MoveToLibrary(vhdl, …….)

       Il ne doit pas y avoir de lignes vides dans le fichier. Nous allons utiliser ce fichier pour
générer le projet en VHDL. Pour cela nous allons modifier quelques lignes dans le fichier.

        On remplace :

Au début du fichier :
NewProject(C:\CreatPlat\projnav\system.ise)
Par: NewProject(C:\CreatPlat\projnav_VHDL\system.ise)

À la fin du fichier:
AddSource(C:\CreatPlat\hdl\system.v, Verilog Design File)
SetProperty( Macro Search Path, C:\CreatPlat\implementation, C:\CreatPlat\hdl\system.v, Implement Design)
## test
SetPreference(UserLevel, Advance)
SetProperty( Hierarchy Separator, /, C:\CreatPlat\hdl\system.v, Synthesize - XST)
SetProperty(Add I/O Buffers, FALSE, C:\CreatPlat\hdl\system.v, Synthesize - XST)
AddSource(C:\CreatPlat\implementation\system.bmm, system)
CloseProject()

Par :
AddSource(C:\CreatPlat\Projnav_VHDL\jpegetbuf_0_wrapper.vhd, VHDL Design File)
MoveToLibrary(C:\CreatPlat\Projnav_VHDL\jpegetbuf_0_wrapper.vhd, JpegEtBuf_v1_00_a)
AddSource(C:\CreatPlat\Projnav_VHDL\system.vhd, VHDL Design File)
## SetProperty( Macro Search Path, C:\CreatPlat\Projnav_VHDL\implementation,
C:\CreatPlat\Projnav_VHDL\system.vhd, Implement Design)
## test
SetPreference(UserLevel, Advance)
## SetProperty( Hierarchy Separator, /, C:\CreatPlat\Projnav_VHDL\system.vhd, Synthesize - XST)
## SetProperty(Add I/O Buffers, FALSE, C:\CreatPlat\Projnav_VHDL\system.vhd, Synthesize - XST)
## AddSource(C:\user_repository\MyProcessorIPLib\pcores\Jpeg2buf_v1_00_a\devl\projnav\, system)
AddSource(C:\CreatPlat\Projnav_VHDL\system.bmm, system)
AddSource(C:\CreatPlat\Projnav_VHDL\system.ucf, system)
CloseProject()

       Une fois les modifications effectuées on enregistre le fichier sous le nom
ise_cmdfile_vhdl. On place ce fichier à la racine du répertoire C:\CreatPlat\, on ouvre ensuite
une fenêtre de commandes DOS. On tape la commande d'exportation vers le logiciel ISE.
       Pjcli –v -f ise_cmdfile_VHDL.

        Si le fichier ise_cmdfile_VHDL a été modifié correctement il n'y a pas d'erreur. Les
lignes commençant par ## sont mises en commentaire. Pour une raison inconnue ses
commandes fonctionnent pour l'exportation en Verilog mais pat pour l'exportation en VHDL.
Il faudra donc les modifier dans le logiciel ISE.

        Il ne reste plus qu'à ouvrir le fichier C:\CreatPlat\ projnav_VHDL\system.vhd avec le
logiciel ISE. Nous pouvons constater la présence de notre composant JPEG et la présence de
toutes les librairies.
       Nous devons maintenant importer les fichiers suivants :
buffer_comp.xco, buffer_comp_chrom.xco, buffer_img.xco, buffer_img_entree.xco,
dct2d.xco, huff_rom.xco, q_rom.xco, tabla_q.xco.
       Dans le menu Projet sélectionner Add Copy of de

       Nous devons maintenant sélectionner le synthétiseur Symplify. Positionner la souris
sur xc2vp30-6ff896 dans le menu Project cliquez sur Properties, dans la fenêtre de dialogue
changer XST (VHDL/Verilog) enSynplify Pro (VHDL/Verilog).
Nous devons maintenant synthétiser le composant JPEG. Avec la souris se placer sur le
composant. Après dans la fenêtre Process for Sources « jpegetbuf_0_wrapper-structure »
sélectionner Synthesis – Synplify Pro lancer la synthèse.
        Comme on peut le constater, le logiciel nous retourne une erreur. Cette erreur vient du
fait que le logiciel ISE n'est pas capable de générer correctement le projet pour le logiciel
Synplify. Nous pourrions éditer le fichier généré par ISE pour le rendre compatible avec
Synplify. Mais le logiciel ISE détecte ces modifications, et ne veut plus effectuer par la suite
la synthèse.
        Nous devons ouvrir le fichier C:\CreatPlat\Projnav_VHDL\ jpegetbuf_0_wrapper.prj avec le
logiciel Synplify. Lancer la synthèse en cliquant sur Run. Le logiciel Synplify génère le
fichier C:\CreatPlat\Projnav_VHDL\ jpegetbuf_0_wrapper.edn .
        Nous retournons maintenant sous ISE pour effectuer la synthèse de la plate-forme
complète. Dans la fenêtre Sources in Project sélectionner system-structure et lancer la
synthèse comme précédemment. Le logiciel ISE produit la même erreur. Il faut ouvrir le
fichier C:\CreatPlat\Projnav_VHDL\system.prj avec le logiciel Synplify et lancer la synthèse en
cliquant sur Run. Le logiciel Synplify génère le fichier C:\CreatPlat\Projnav_VHDL\
system.edn .
        Maintenant tous les fichiers ont été synthétisés. Malheureusement notre projet
« system.ise » sous le logiciel ISE ne peut pas être utilisé pour continuer. Les erreurs de
synthèse sous ISE empêchent la phase de placement routage.
        Pour continuer nous devons créer un autre projet avec le logiciel ISE. Les fichiers
composant ce projet ne seront plus en langage VHDL mais seront les fichiers EDIF
synthétisés.

        On crée un nouveau projet C:\CreatPlat\Projnav_VHDL\Plat_synth\ Plat_synth.ise. On
sélectionne dans le menu Projet Add Copy of Sources pour ajouter les fichiers EDIF.




       Ce sont les fichiers system.bmm system.edn system.ucf . Dans un second temps nous devons
prendre soin de copier dans le répertoire du nouveau projet les autres fichiers EDIF
nécessaires au placement routage.
        Il faut juste copier ces fichiers dans le répertoire surtout ne pas les ajouter au projet
sous le logiciel ISE. Nous devons aussi indiquer au logiciel de placement routage où se trouve
les fichiers de synthèse des autres IPs de notre plate-forme. Dans la fenêtre Processes for
Sources on sélectionne les propriétés pour Implement Design. Dans les propriétés de l'onglet
Translate Properties on renseigne la case Macro Search Path avec le répertoire
C:\CreatPlat\Projnav_VHDL\implementation\




        Nous pouvons maintenant générer le fichier à télécharger dans le FPGA. Il ne suffit de
lancer la commande Generate Programming File dans la fenêtre Processes for Source. Une
fois que le fichier system.bit aura été généré il faudra lancer le logiciel Impact pour
télécharger le fichier dans le FPGA.

								
To top