See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/276409231

Reconfiguration des FPGA

Technical Report · May 2015

CITATIONS READS

0 1,146

2 authors:

Mehdi Jemai Bouraoui Ouni

National Engineering School of Monastir national engineering school of Sousse
15 PUBLICATIONS   28 CITATIONS    99 PUBLICATIONS   244 CITATIONS   

SEE PROFILE SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Real time video processing View project

real time video processing View project

All content following this page was uploaded by Bouraoui Ouni on 17 May 2015.

The user has requested enhancement of the downloaded file.

 REPUBLIQUE TUNISIENNE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE

SCIENTIFIQUE

Université de Sousse
Ecole nationale d’ingénieurs de Sousse

Département Electronique Industriel (EI)

Fascicule de travaux pratiques

3ème année électronique industriel
Option : Systèmes Electroniques Embarqués

Reconfiguration des FPGA

Enseignants : Mr. Mehdi JEMAI

Mr. Bouraoui OUNI

Année Universitaire 2014-2015

Ecole Nationale d'Ingénieurs de Sousse, Adresse : BP 264 Sousse Erriadh 4023

Tél.: +216 73 369 500 - +216 73 369 501 - 216 73 369 502 Fax : +216 73 369 506
 Présentation du TP
 Parcours : 3ème année électronique industriel
 Semestre : S1
 Unité d’enseignement : UE4
 Option 3: Systèmes Electroniques Embarqués
 Intitulé du module : Reconfiguration des FPGA
 Nombre d’heures : 21
 Crédits : 03
 Système d’évaluation : Contrôle continu

Résumé

Les TP de reconfiguration des FPGA sont destinés aux étudiants de troisième année
ingénieur électronique industriel de l’option Systèmes Electroniques Embarqués.
Ils permettent aux étudiants ingénieurs d’approfondir leurs connaissances dans
l’électronique, la micro-électronique et à maîtriser tous ce qui est vu en cours systèmes
embarqués dans le langage de description matériel VHDL et sous l’éditeur ISE de Xilinx.

Objectif Général

Ces travaux pratiques visent à approfondir les compétences acquises par l’apprenant en
description matériel (VHDL) :
- Connaître les bases conceptuelles et physiques de l'électronique,
- Maîtriser les technologies de pointe et exploiter les connaissances acquises pour la
conception et la réalisation de systèmes dans les différents champs d'application de
l'électronique industrielle,
- Acquérir une approche scientifique dans la résolution des problèmes et approfondir
les connaissances complémentaires nécessaires au travail d'un ingénieur,
- Communiquer efficacement ses idées et travailler seul ou en équipe.

Contenu théorique

- TP N 1 : Les différents modes de reconfiguration d’un FPGA.

- TP N 2 : La mémoire interne du FPGA (BRAM).
- TP N 3&4 : La reconfiguration dynamique partielle.
 Table des matières

Manipulation n°1 : Les différents modes de reconfiguration d’un FPGA..............................1

1. But de la manipulation ...............................................................................................................1
2. Etude théorique ..........................................................................................................................1
2.1. Région reconfigurable ..........................................................................................................1
2.2. Les différents modes de reconfiguration ..............................................................................1
2.2.1. Reconfiguration sans région reconfigurable ........................................................................1
2.2.2. Reconfiguration avec région reconfigurable par le mode slice ............................................2
2.2.3. Reconfiguration avec région reconfigurable par le mode bloc ............................................2
3. Travail demandé .........................................................................................................................3
3.1. Précautions ..............................................................................................................................3
3.2. ISE: Synthèse et simulation.....................................................................................................3
3.3. ISE: Implémentation ...............................................................................................................8
Questions: .....................................................................................................................................13

Manipulation 2 : La mémoire interne du FPGA (BRAM) .....................................................14

1. But de la manipulation .............................................................................................................14
2. Etude théorique ........................................................................................................................14
2.1. Définitions .............................................................................................................................14
2.2 Différent types de mémoire vive ............................................................................................14
2.2.1. Mémoire vive statique ........................................................................................................14
a. Static Random Access Memory (SRAM) ..............................................................................15
b. Dual Ported Random Access Memory (DPRAM) .................................................................15
c. Magnetic Random Access Memory (MRAM) .......................................................................15
d. Phase-Change Random Access Memory (PRAM) ................................................................15
2.2.2. Mémoire vive dynamique...................................................................................................15
2.3. Le bloc mémoire interne du FPGA de Xilinx .......................................................................15
3. Travail demandé .......................................................................................................................17
3.1. Précautions ............................................................................................................................17
3.2. ISE: Synthèse et simulation...................................................................................................17
3.3. ISE: Implémentation .............................................................................................................21

Manipulation n°3&4 : La reconfiguration dynamique partielle ...........................................23

1. But de la manipulation .............................................................................................................23
2. Etude théorique ........................................................................................................................23
2.1. Architecture reconfigurable...................................................................................................23
2.2. La reconfiguration statique....................................................................................................23
2.3. La reconfiguration dynamique ..............................................................................................24
2.3.1. La reconfiguration dynamique totale (RDT) ......................................................................24
2.3.2. La reconfiguration dynamique partielle (RDP) ..................................................................25
2.4 Wrapper ..................................................................................................................................26
2.5. Bus de communication ..........................................................................................................27
3. Travail demandé .......................................................................................................................29
3.1. Précautions ............................................................................................................................29
3.2. ISE: Synthèse et simulation...................................................................................................29
3.2.1. Les modules........................................................................................................................29
3.2.2. Module global ....................................................................................................................31
3.2.2.1. La reconfiguration statique..............................................................................................32
3.2.2.2. La reconfiguration dynamique partielle ..........................................................................33
3.3. ISE: Implémentation .............................................................................................................35
3.3.1. Module global ....................................................................................................................35
3.3.2. Les modules actifs ..............................................................................................................36
3.3.3. Assemblage des modules ...................................................................................................37
3.3.4. Création des bitstreams ......................................................................................................38

Annexes
3 éme E.I TP1

Manipulation n°1 : Les différents modes de reconfiguration d’un

FPGA

1- But de la manipulation
Les objectifs de cette manipulation sont les suivants :
 Etudier les différents modes de reconfiguration d’un FPGA.
 Déterminer les avantages et les inconvénients de chaque mode de reconfiguration.
2- Etude théorique
2-1- Région reconfigurable
Par définition, une région reconfigurable constitue l’ensemble de ressources matérielles où
se fait l’implémentation physique du design. En effet, la surface de le FPGA avec ses divers
éléments logiques, de mémorisation et arithmétiques représente une région reconfigurable
pour le placeur de design.
2-2 Les différents modes de reconfiguration
2-2-1 Reconfiguration sans région reconfigurable
La reconfiguration sans région reconfigurable utilise tout le FPGA à chaque configuration,
c'est-à-dire toutes les ressources matérielles sont occupées pendant l’exécution d’une
application alors qu’elles ne sont pas réellement utilisées comme l’illustre la figure 1.

Figure 1: Reconfiguration sans région reconfigurable

Eniso 2014-2015 1
3 éme E.I TP1

2-2-2 Reconfiguration avec région reconfigurable par le mode slice

Ce mode de reconfiguration avec région reconfigurable consiste à implémenter le design de
l’application sur des régions reconfigurables prédéfinies. Chaque région représente un module
spécifique d’une application. Pour ce mode de reconfiguration, plusieurs contraintes sont
exigées sur la zone allouée pour l’implémentation des modules de l’application:
 La largeur du module doit être obligatoirement un multiple de 4 slices.
 Le module doit être étalé sur toute la hauteur de le FPGA utilisé.
 La taille et la position du module ne doivent pas être modifiées lors de l'exécution de
la tâche.
 Les ressources logiques couvertes par la zone reconfigurable, comme les
multiplicateurs, les slices, les bloques RAM ainsi que toutes les ressources de routage,
sont considérées comme une partie de module.
La figure 2 ci-dessous, illustre le principe du mode slice et les contraintes exigées :

Figure 2: Mode slice

2-2-3 Reconfiguration avec région reconfigurable par le mode bloc
Le mode bloc est un nouveau mode qui consiste à mettre la région reconfigurable en deux
dimensions, contrairement au mode slice qui exige l’utilisation de toute la hauteur de le
FPGA. Il convient de signaler que la taille minimale de chaque bloc est de quatre slices. La
figure 3 illustre le principe du mode bloc.

Eniso 2014-2015 2
3 éme E.I TP1

Figure 3: Mode bloc

3- Travail demandé
3-1 Précautions.
La manipulation est réalisée avec une carte de développement Nexys 3, Il conviendra donc
de faire les changements appropriés en fonction de la carte de l’utilisateur.
3-2 ISE: Synthèse et simulation.
ISE est un outil qui permet de synthétiser le système logique, d’après le code VHDL de
l’utilisateur. Il permet également de créer des fichiers de simulations ou Test Bench qui sont
utiles à la validation du fonctionnement du système.
Etape 1 : Créer un projet.
Etape 2 : Ajouter des modules au projet.
Etape 3 : Synthèse.
Etape 4 : Simulation.

Etape 1 : Créer un projet.

1. Sélectionner Démarrer > Programmes > Xilinx ISE Design Suite13.4 > ISE Design
Tools > Project Navigator.
2. Dans Project Navigator, créer un nouveau projet en faisant File > New Project.
3. Entrer Le nom du projet et dans location ajouter \tp1 pour créer un répertoire spécifique à
ISE. Puis cliquer sur Next.

Eniso 2014-2015 3
3 éme E.I TP1

Figure 4: Création d’un projet ISE

4. Dans Project Settings, choisir une carte de développement, ici Nexys 3 Spartan 6
xc6slx16-3 csg324. Cliquer sur Next, Puis Finish.

Figure 5: Paramètres du projet

Eniso 2014-2015 4
3 éme E.I TP1

Figure 6: Fenêtre principale ISE

Nous avons donc une interface scindée en trois parties principales:
 A gauche, La partie design, qui répertorie les modules VHDL et permet de synthétiser
et de lancer le simulateur.
 A droite, La partie grise va permettre principalement d’éditer le code VHDL.
 En bas, la console où l’on voit les étapes de la synthèse, les erreurs et warnings.

Etape 2 : Ajouter des modules au projet :

1. Clic droit sur La cible et New Source
2. Sélectionner VHDL Module et saisir le nom du module ici tp1 et cliquer Next.

Figure 7: Sélection type de ficher

Eniso 2014-2015 5
3 éme E.I TP1

3. Editer ensuite le nom des entrées/Sorties, et leurs caractéristiques (in/out, bus/bit). Cette
étape est facultative. Cliquer Next puis Finish.

Figure 8: Définition de l’entité

4. Editer le code VHDL.

Figure 9: Code VHDL

Eniso 2014-2015 6
3 éme E.I TP1

Etape 3 : Synthèse
1. Sélectionner le module et double clic sur Synthesize – XST dans la fenêtre de dessus.
2. On voit alors dans la console la synthèse qui s’effectue et le rapport des erreurs et des
warnings. Corriger les erreurs éventuelles, les warnings peuvent être ignorés.

Etape 4 : Simulation
Pour la simulation nous devons créer un fichier Test Bench, qui est un fichier VHDL qui
permet de créer des stimulus pour les entrées.
Pour créer un TestBench :
1. Clic droit sur la cible et New Source.
2. Sélectionner VHDL Test Bench et donner un nom, ici test, puis cliquer Next.
3. Sélectionner le module à tester, cliquer Next, puis Finish.
4. Dans la fenêtre Design en haut, il y a deux boutons radio, sélectionner Simulation. On voit
alors apparaître le Test Bench et son module associé.
5. Pour ajouter des stimulus, double clic sur test. En déroulant le code, on trouve une ligne de
commentaire Stimulus process, mais dans notre cas on utilise Clock process definitions,
ajouter les stimulus ici :

Figure 10: Stimulu pour TestBench.

6. Pour lancer la simulation, cliquer sur le Test Bench à simuler, et dans la fenêtre de process,
double clic sur Simulate Behavioral Model. ISE lance alors Isim. Il est possible que Isim
plante, alors il faut quitter Isim et le relancer autant de fois qu’il plante en double cliquant sur
Simulate Behavioral Model.

Eniso 2014-2015 7
3 éme E.I TP1

3-3 ISE: Implémentation

L’implémentation permet la translation du système logique synthétisé vers l’implantation
physique sur le FPGA. Par la suite, cette phase consiste à réaliser le mappage, le placement et
routage de l’application.
Etape 1 : Déterminer les contraintes temporelles et déclaration des pins d’entrées/sorties.
Etape 2 : Déterminer les contraintes surfaciques.
Etape 3 : Mappage, placement et routage.

Etape 1 : Déterminer les contraintes temporelles et la déclaration des pins d’entrées/sorties.

Cette phase consiste à spécifier les pins d’entrées/sorties et les contraintes temporelles (s’il
existe des horloges dans le design) dans un fichier UCF (User Contraints File).
1. Sélectionner le module et dérouler " la plus " à côté de User Contraints (voir Figure 9).
Puis double clic sur Create Timing Constraints, puis cliquer sur yes.
2. Compléter les champs nécessaires et puis cliquer sur Validate Constraints, puis
enregistrer le fichier UCF.

Figure 11: Contraintes temporelles

3. Assigner les pins d’entrées/sorties de le FPGA aux ports convenables de design dans notre
cas les 8 diodes leds et l’horloge. En outre, sélectionner le module et dérouler " la plus " à
côté de User Contraints. Puis, double clic sur I/O Pin Planning (Plan Ahead) - Post
Synthesis, puis cliquer yes.
4. Sélectionner I/O Ports > All ports. Puis saisir les informations de tous les pins.

Composant Pin FPGA

Led 0 U16
Led 1 V16
Led 2 U15
Led 3 V15
Led 4 M11
Led 5 N11
Led 6 R11
Led 7 T11
Horloge V10

Eniso 2014-2015 8
3 éme E.I TP1

Figure 12: Les pins d’entrées/sorties

5. Sélectionner File > Save Design et exit le PlanAhead
6. Pour vérifier toutes les contraints temporelles et l’emplacement de différents pins
d’entrées/sorties ouvrir le fichier ".UCF"

Figure 13: Le fichier ".UCF"

Etape 2 : Déterminer les contraintes surfaciques.

Dans cette étape on va étudier les différents modes de reconfiguration de le FPGA :

Eniso 2014-2015 9
3 éme E.I TP1

Mode 1 : Reconfiguration sans région reconfigurable

Ce mode consiste à implémenter notre application sans contraintes surfacique c'est-à-dire
sans la déclaration de la région reconfigurable. Donc on doit passer à l’étape 3 de
l’implémentation.
Mode 2 : Reconfiguration avec région reconfigurable par le mode slice
1. Sélectionner le module et dérouler " la plus " à côté de User Contraints. Puis double
clic sur Floorplan Area/IO/Logic (PlanAhead), puis cliquer yes.
2. Dans Physical Constraints sélectionner ROOT, clic droit et choisir New Pblock,
renommer le Pblock puis ok

Figure 14: Pblock

3. Clic droit sur le nouveau Pblock tp1 et choisir Set Pblock Size. Dans ce mode il faut
étaler le rectangle tout au long de la hauteur de le FPGA et la largeur est un multiple de
4 slices.

Figure 15: Pblock en mode slice

Eniso 2014-2015 10
3 éme E.I TP1

Remarque : le nombre d’éléments disponibles dans la région reconfigurable et le nombre

requis par le design sont présentés dans Pblock Properties. Si le nombre d’éléments est
insuffisant dans la région créée, les nombres sont indiqués en rouge. Il faut alors redessiner un
autre rectangle.

Figure 16: Contraintes physiques

4. Dans la fenêtre Netlist, clic droit sur Primitives et choisir Assign. Dans Select Pblock
sélectionner le Pblock désiré puis ok.
5. Enregistrer et fermer le PlanAhead.

Mode 3 : Reconfiguration avec région reconfigurable par le mode bloc

Refaire les mêmes étapes de mode slice sauf que la taille de Pblock sera en deux
dimensions (longueur et largeur).

Figure 17: Pblock en mode bloc

Eniso 2014-2015 11
3 éme E.I TP1

Etape 3 : Mappage, placement et routage.

1. Dans la fenêtre Processes sélectionner Implement Design et choisir Run dans le

menu du bouton droit.
2. Corriger les erreurs s’ils existent et vérifier la région reconfigurable pour chaque
mode. Sélectionner Implement Design > Place&Route > double clic sur Analyze
Timing/Floorplan Design (PlanAhead).
3. Pour vérifier le routage de design sélectionner Implement Design > Place&Route >
double clic sur View/Edit Routed Design (FPGA Editor).
4. Pour estimer la quantité de puissance consommée par le design sélectionner
Implement Design > Place&Route > double clic sur Analyze Power Distribution
(XPower Analyzer). Puis dans la fenêtre Report Navigator > View > Details > By
Clock Domain éditer la fréquence qui convient au design.

Figure 18: Xilinx Xpower Analyzer

Eniso 2014-2015 12
3 éme E.I TP1

Questions :

1. Remplir le tableau suivant pour les trois modes de reconfiguration à l’aide des rapports
dans la fenêtre Design Summary > Detailed Reports

Mode 1 Mode 2 Mode 3

Temps de placement
Temps de routage
Puissance totale
Ressources utilisées
Fréquence maximale

2. Comparer entre les trois modes de reconfiguration à l’aide de graphe en radar, en

utilisant comme paramètre la puissance totale, les ressources utilisées et la fréquence
maximale. Conclure ?

Eniso 2014-2015 13
3 éme E.I TP2

Manipulation 2 : La mémoire interne du FPGA (BRAM)

1- But de la manipulation

Les objectifs de cette manipulation sont :

 Etude du bloc mémoire interne du FPGA de Xilinx.

 Implémentation d’une application en utilisant un bloc mémoire BRAM.

2- Etude théorique

2-1 Définitions

La mémoire vive ou aussi appelée RAM (Random Access Memory) (mémoire à accès
direct), est une mémoire dans laquelle une unité de calcul place les données lors de leur
traitement. La mémoire vive (RAM) est généralement une mémoire volatile au contraire de la
mémoire morte (ROM) : les données contenues dans la mémoire vive seront perdues dés
qu’une coupure d'alimentation électrique se produit. Donc, la mémoire vive se trouve dans un
état indéterminé dés le début de fonctionnement.

La RAM présente la particularité de pouvoir être accédée à la fois en lecture et en écriture.

Une activation électronique appropriée permet au besoin, de verrouiller temporairement en
écriture des blocs physiques donnés. L'adressage d'une mémoire (traduction de tensions
électriques sur des fils en adresse mémoire) se fait par un mécanisme nommé le chip select.

Les informations peuvent être organisées en 1, 2, 4, 9, 18, ou 36 Bits.

2-2 Différent types de mémoire vive

2-2-1 Mémoire vive statique

Une mémoire vive statique est une mémoire vive qui n'a pas besoin de rafraîchissement. Le
rafraîchissement de la mémoire est un processus qui consiste à lire périodiquement les
informations d'une mémoire et les réécrire immédiatement sans modifications, dans le but de
prévenir la perte de ces informations.

Eniso 2014-2015 14
3 éme E.I TP2

a- Static Random Access Memory (SRAM)

Cette mémoire utilise le principe des bascules électroniques pour enregistrer l'information.
Elle est très rapide, par contre, elle est chère et volumineuse. Elle consomme moins
d'électricité que la mémoire dynamique. Elle est utilisée pour la mémoire cache, par exemple
les mémoires caches L1, L2 et L3 des microprocesseurs.

b- Dual Ported Random Access Memory (DPRAM)

Cette mémoire est une variante de la Static Random Access Memory (SRAM) où on utilise
un port double qui permet des accès multiples quasi simultanés, en entrée et en sortie.

c- Magnetic Random Access Memory (MRAM)

Cette mémoire utilise la charge magnétique de l'électron pour enregistrer l'information. Elle
possède un débit de l'ordre du gigabit par seconde, un temps d'accès comparable à la mémoire
DRAM (~10 ns) et elle est non-volatile. Elle a commencé à être commercialisée en 2006.

d- Phase-Change Random Access Memory (PRAM)

Cette mémoire utilise le changement de phase du verre pour enregistrer l'information. Elle
est non-volatile. Elle a commencé à être commercialisée en 2012.

2-2-2 Mémoire vive dynamique

Une mémoire vive dynamique est une mémoire qui a besoin de rafraîchissement. La
DRAM a une structure simple, en effet, un pico-condensateur et un transistor pour un bit,
permet d'obtenir une mémoire dense à coût minime. Son inconvénient réside dans les courants
de fuite des condensateurs : l'information disparaît à moins que la charge des condensateurs
ne soit rafraîchie avec une période de quelques millisecondes. D'où le terme de dynamique.

2-3 Le bloc mémoire interne du FPGA de Xilinx

La mémoire interne du FPGA de Xilinx possède la structure présentée dans la figure 1(pour
plus d’information voir annexe). Elle contient généralement deux ports A et B. Chaque port
est constitué par des bus d’adresses, de données et de contrôle. Ces bus permettent la lecture
et l’écriture dans la mémoire.

Eniso 2014-2015 15
3 éme E.I TP2

Figure.1 : BRAM
La figure 2 montre le principe de fonctionnement de BRAM. Tout d’abord, la mémoire est
initialisée par exemple à la valeur FFFF dans l’adresse a0, à la valeur ABCD sur le bus de
données et à 1001 (0=lecture, 1= écrire) sur le bus de contrôle. Ensuite, au front montant de
l’horloge, nous remarquons que le continu et la valeur de sortie de la mémoire prennent la
valeur AFFD.

Figure.2 : Chronogramme
Dans cette manipulation nous allons étudier la mémoire RAMB16_S2_S4 (voir annexe).
Ores et déjà, nous allons choisir à utiliser le port A. Le composant RAMB est déclaré comme
suit:
component RAMB16_S2_S4

port (
DIA : in STD_LOGIC_VECTOR (1 downto 0);
DIB : in STD_LOGIC_VECTOR (3 downto 0);

Eniso 2014-2015 16
3 éme E.I TP2

ENA : in STD_logic;
ENB : in STD_logic;

WEA : in STD_logic;
WEB : in STD_logic;

SSRA : in STD_logic;
SSRB : in STD_logic;

CLKA : in STD_logic;
CLKB : in STD_logic;

ADDRA : in STD_LOGIC_VECTOR (12 downto 0);

ADDRB : in STD_LOGIC_VECTOR (11 downto 0);

DOA : out STD_LOGIC_VECTOR (1 downto 0);

DOB : out STD_LOGIC_VECTOR (3 downto 0));
end component;

3- Travail demandé

3-1 Précautions.

La manipulation est réalisée avec une carte de développement Spartan 3, Il conviendra

donc de faire les changements appropriés en fonction de la carte de l’utilisateur.

3-2 ISE: Synthèse et simulation.

Etape 1 : Créer un projet.

Etape 2 : Ajouter des modules au projet.
Etape 3 : Synthèse.
Etape 4 : Simulation.
Etape 1 : Créer un projet.
1. Sélectionner Démarrer > Programmes > Xilinx ISE Design Suite13.4 > ISE Design
Tools > Project Navigator.
2. Dans Project Navigator, créer un nouveau projet en faisant File > New Project.
3. Entrer le nom du projet top et dans location ajouter \tp2 pour créer un répertoire spécifique
à ISE. Puis Cliquer Next.

Eniso 2014-2015 17
3 éme E.I TP2

Figure 3: Création de projet ISE

4. Dans Project Settings, choisir une carte de développement, ici Spartan 3 xc3s200-5 ft256.
Cliquer Next, puis Finish.

Figure 4: les paramètres de projet

Eniso 2014-2015 18
3 éme E.I TP2

Etape 2 : Ajouter des modules au projet :

1. Clic droit sur la cible et New Source
2. Sélectionner VHDL Module et saisir le nom du module ici top et cliquer Next.

Figure 5: Sélection du type de fichier

3. Editer ensuite le nom des entrées/Sorties, et leurs caractéristiques (in/out, bus/bit) (voir
figure 6). Cette étape est facultative. Cliquer Next puis Finish.

Figure 6: Entête de module top

Eniso 2014-2015 19
3 éme E.I TP2

4. Editer le code VHDL.

Remarque : Recommencer l’étape 2 autant de fois qu’il y a de modules.

Pour l’application, il y a 4 Modules :

 Bram : module qui contient le bloc mémoire.
 Com : module pour l’adressage et la gestion des signaux de contrôle de la mémoire.
 Afficheur : module de transcodage pour l’afficheur 7 segments.
 Top : module global ou on va insérer tous les modules.

Figure 7: Module top

5- A l’aide des fichiers afficheur.vhd, com.vhd, Bram.vhd et la figure 7, construire le module

global top.

Etape 3 : Synthèse
1. Sélectionner le module et dans la fenêtre de dessous, double clic sur Synthesize – XST.
2. On voit alors dans la console la synthèse qui s’effectue et le rapport des erreurs et des
warnings. Corriger les erreurs éventuelles, les warnings peuvent être ignorés.

Eniso 2014-2015 20
3 éme E.I TP2

Etape 4 : Simulation
Pour la simulation nous avons besoins de créer un fichier Test Bench, qui est un fichier
VHDL qui permet de créer des stimulus pour les entrées.
Pour créer un TestBench :
1. Clic droit sur la cible et New Source.
2. Sélectionner VHDL Test Bench et donner un nom, ici test, puis cliquer Next.
3. Sélectionner le module à tester, cliquer Next, puis Finish.
4. Dans la fenêtre Design en haut, il y a deux boutons radio, sélectionner Simulation. On voit
alors apparaître le Test Bench et son module associé.
5. Pour ajouter des stimulus, double clic sur test. En déroulant le code, on trouve une ligne de
commentaire Stimulus process et Clock process definitions.
6. Proposer des stimulus sur les entrées pour tester notre application.
7. Pour lancer la simulation, cliquer sur le Test Bench à simuler, et dans la fenêtre des
process, double clic sur Simulate Behavioral Model. ISE lance alors Isim. Il est possible que
Isim plante, il faut quitter Isim et le relancer autant de fois qu’il plante en double cliquant sur
Simulate Behavioral Model.

3-3 ISE: Implémentation.

Cette phase consiste à spécifier les pins d’entrées/sorties et les contraintes temporelles (s’il
existe des horloges dans le design) dans un fichier UCF (User Contraints File).
1. Sélectionner le module et dans la fenêtre de dessous, dérouler la plus à côté de User
Contraints. Puis double clic sur Create Timing Constraints, puis cliquer yes.
2. Compléter les champs nécessaires et puis cliquer sur Validate Constraints, puis
enregistrer le fichier UCF.

Figure 8: Contraintes temporelles

3. Assigner les pins d’entrées/sorties de le FPGA aux ports convenables de design dans notre
cas ces sont, les 7 diodes leds, l’afficheur à 7 segments, les 4 boutons poussoirs, les 5
switcheurs et l’horloge 50 Mhz. En outre, sélectionner le module et dans la fenêtre de
dessous, dérouler la plus à côté de User Contraints. Puis, double clic sur I/O Pin
Planning (Plan Ahead) - Post Synthesis, puis cliquer yes.

Eniso 2014-2015 21
3 éme E.I TP2

4. Sélectionner I/O Ports > All ports. Puis saisir les informations de tous les pins (voir
annexe).
5. Sélectionner File > Save Design et exit le PlanAhead
6. Pour vérifier tous les contraints temporelles et l’emplacement de différents pins
d’entrées/sorties ouvrir le fichier ".UCF".
7. Implémenter le design sur la carte FPGA et vérifier le fonctionnement du
BRAM "RAMB16_S2_S4 ".

Eniso 2014-2015 22
3 éme E.I TP3&4

Manipulation n°3&4 : La reconfiguration dynamique partielle

1- But de la manipulation

Les objectifs de cette manipulation sont :

 Etudier la reconfiguration statique et dynamique du FPGA de Xilinx.

 La mise en œuvre de la reconfiguration dynamique partielle.

 Implémentation d’une application en utilisant la reconfiguration dynamique partielle.

2- Etude théorique

2.1- Architecture reconfigurable

L’architecture est l’art de combiner et de concevoir au moyen de techniques appropriées,

des éléments ou des composants destinés à réaliser une fonction. Le terme reconfigurable
signifie le changement d’une fonction après le processus de réalisation. En effet, la combinaison
de ces deux termes ‘‘architecture’’ et ‘‘reconfigurable’’ donne naissance à des systèmes
numériques d’une nouvelle architecture plus flexible et modifiable par rapport à l’architecture
câblée qui reste inchangeable après sa fabrication. Dans cette perspective, un système
numérique ne sera considéré comme reconfigurable que s’il comporte plusieurs composants de
base tels que les éléments logiques et arithmétiques reconfigurables, interconnectés par un
réseau d’interconnexion reconfigurable. On pourrait configurer une architecture reconfigurable
de manière statique ou dynamique.

2.2- La reconfiguration statique

La reconfiguration statique consiste à charger au sein du circuit reconfigurable une

configuration avant le commencement de l’exécution de l’application ; comme l’indique la
figure 1. En suite, le FPGA préserve sa configuration tout au long du déroulement de
l’application. Dés lors, la configuration sera effacée s’il y a un signal de réinitialisation totale
(Reset de le FPGA) ou bien pendant le chargement d’une nouvelle configuration.

Eniso 2014-2015 23
3 éme E.I TP3&4

Début de l’exécution

Configuration Exécution

Figure 1: La reconfiguration statique

2.3-. La reconfiguration dynamique

La reconfiguration dynamique est divisée en deux approches selon l’allocation des

matériels en une reconfiguration dynamique totale (RDT) ou en une reconfiguration
dynamique partielle (RDP).

2.3.1- La reconfiguration dynamique totale (RDT)

La reconfiguration dynamique totale a été introduite en raison des contraintes de

ressources. Il n'est pas toujours possible d'implémenter d'une manière statique des
applications de taille importante. Ainsi une seule partie de l'application réside dans le
matériel. D’ailleurs, il est possible de partager l’application en tâches. Chacune d’elles
représente une configuration qui occupe toutes les ressources reconfigurables comme illustre
la figure 2.

On vielle à ce que les tâches soient plus au moins de même taille. Le partitionnement
d’une application est itératif car il est difficile de juger la taille d’une partition avant le
placement et le routage. Il faut créer une partition initiale comme modèle en vue d’obtenir des
partitions de taille équivalente. Il convient à signaler que la reconfiguration dynamique totale
a des inconvénients qui sont l’origine de la complexité de l’opération. En premier lieu, Si on
n'est pas capable de le faire, l'usage des ressources de le FPGA ne sera pas efficace. En
second lieu, un problème de transition d’une configuration à une autre se pose en cas de
dépendance des données. Des configurations produisent des données intermédiaires qui
formeront les données d'entrées de la prochaine configuration chargée. Elles doivent être ainsi
construites d'une manière très rigoureuse en tenant compte des différentes phases de
l'application pour que les données intermédiaires soient correctement gérées. En dernier lieu,
ces configurations remplaçables restent respectivement dans le circuit durant une période

Eniso 2014-2015 24
3 éme E.I TP3&4

déterminée, néanmoins presque tous les outils de développement considèrent chacune d’elles
comme un modèle statique.

Figure 2: La reconfiguration dynamique totale

2.3.2- La reconfiguration dynamique partielle (RDP)

La reconfiguration dynamique partielle est une approche plus flexible que la

reconfiguration dynamique totale au niveau de l’allocation des ressources matérielles. Elle se
fait d’une manière locale pendant l’exécution de l’application. En effet, elle réduit le nombre
de ressources configurables, cela permet de gagner du temps de configuration. L’approche de
la reconfiguration dynamique partielle engendre une meilleure utilisation de le FPGA. En fait,
on configure des parties dynamiques du système tout en conservant les parties statiques.

La conception des applications avec la reconfiguration dynamique partielle est basée sur
un partitionnement fonctionnel. Ces partitions ne doivent pas être entièrement exclusives
puisque elles peuvent être toutes actives en même temps, alors qu'avec la RDT il n'y a qu'une
seule partition qui est active à un instant donné. Toutes ces partitions ou opérations de la RDP
peuvent être considérées comme des modules indépendants qui sont chargés dans les FPGAs.
La figure 3 suivante illustre le principe de la reconfiguration dynamique partielle.

Eniso 2014-2015 25
3 éme E.I TP3&4

Figure 3: La reconfiguration dynamique partielle

Puisqu’elle procure divers avantages La reconfiguration dynamique partielle est utilisée

dans plusieurs domaines tels que l’aérospatiale, la robotique, la cryptographie et
l’informatique... D’abord, elle engendre l’augmentation des performances de système qui
devient capable d'exécuter plusieurs applications sur un seul FPGA. En outre, elle entraine
une telle technique qui favorise l’accélération de traitement des données dans le domaine de
traitement d’image et vidéo. Puis, elle réduit le temps de configuration. En conséquence,
l’application devient rapide tout en maintenant la notion de temps réel. Enfin, la
reconfiguration dynamique partielle permet de réduire le coût et la puissance consommée.

2.4-Wrapper

Pour travailler en reconfiguration dynamique partielle, il est nécessaire d’avoir une partie
statique et une partie dynamique ou reconfigurable. La région reconfigurable est fixe dans le
FPGA, les modules s’intégrant à cette région, sont soumis à certaines contraintes physiques.
Ils doivent avoir un Wrapper identique à la région reconfigurable, et donc un Wrapper
identique entre eux. Ce Wrapper est l’interface de communication entre la partie
reconfigurable et le reste du système, autrement dit, ce sont les entrées et les sorties des
modules. Les modules doivent avoir en commun, le nombre d’entrées/sorties, les noms des
entrées et des sorties et leur taille, comme le montre la figure 4 suivante.

Eniso 2014-2015 26
3 éme E.I TP3&4

Figure 4: Wrappers Communs aux modules.

Chaque bit d’entrées/sorties est connecté à une interface de communication (Bus macro,
Slice Bus Macro ou Pins Partition). On Voit donc qu’avec cette méthode on est limité en
flexibilité, bien que l’on puisse créer d’autres régions reconfigurables, les modules sont
dépendants du Wrapper de la région à laquelle ils appartiennent. D’autres méthodes avec
Wrapper dynamique, pourront être utilisées.

2.5-. Bus de communication

Le flux de communications entre les modules est routé d’une façon arbitraire pour la
reconfiguration dynamique totale. Par contre, les contraintes spatiales de la reconfiguration
dynamique partielle exigent le cheminement de flux de communication entre les modules
reconfigurables et les autres modules par un bus spécialisé appelé bus macro.

Eniso 2014-2015 27
3 éme E.I TP3&4

Le bus macro est la seule moyen qui assure la connexion des modules reconfigurables
avec le reste de l’architecture c'est-à-dire tout les signaux doivent passer à travers le bus
macro. Sauf les signaux globaux tels que l’horloge, Vcc et GND se sont traités par l’outil de
conception. Le bus macro à subi une évolution au niveau de sa structure et son constitution ce
qui a permis d’avoir une diversité des bus macro.

En effet, pour construire des bus macro de grande taille selon l’application nous faisons
l’instanciation des plusieurs composants de bus pris de la bibliothèque sous le format
‘‘.nmc’’. Par exemple, les données sont de taille de huit bits donc nous allons construire un
bus macro constitué par deux instances de bus de la bibliothèque.

Les nouveaux bus macro se basent sur des LUT comme illustre la figure 5 contrairement
aux anciens bus macro qui se basent sur les contrôleurs (buffers) à trois états qui sont
commandés suivant le sens voulu de droite à gauche au inversement.

Figure 5 : Exemple de bus macro a base de LUT.

Les bus sont classés selon le sens, la largeur et le temps de synchronisation dans plusieurs
types.

 Sens: Selon la direction de signal de donnée nous utilisons les bus macro qui convient
soit de droite à gauche (R2L) ou de gauche à droite (L2R).

 Largeur physique: Il y a des bus de largeur de quatre CLB (Narrow) et d’autres de

largeur deux CLB(Wide).

 Temps de synchronisation: Il y a des bus synchrone et d’autres asynchrone mais les

bus synchrone offre une grande performance de point de vue temps de synchronisation

Eniso 2014-2015 28
3 éme E.I TP3&4

3- Travail demandé

3-1 Précautions

La manipulation est réalisée avec l’outil ISE10.1 et une carte de développement Virtex II
PRO, Il conviendra donc de faire les changements appropriés en fonction de la carte de
l’utilisateur. Les modules utilisés sont un compteur modulo 3, décompteur modulo 3, un
afficheur.

Figure 6 : Les modules

3-2 ISE: Synthèse et simulation

3-2-1 Les modules

Etape 1 : Structure de projet.

Etape 2 : Créer un projet.
Etape 3 : Synthèse.
Etape 4 : Simulation.
Etape 1 : Structure de projet

La structuration de différents fichiers utilisés et générés pendant les différentes étapes de

la mise en œuvre de la RDP est très importante vu le grand nombre des types de ces fichiers.
Afin de bien planifier nos fichiers, nous avons choisi la structure présentée dans la figure 7.

Figure 7 : Structure du projet

Eniso 2014-2015 29
3 éme E.I TP3&4

Etape 2 : Créer un projet.

Tout d’abord, nous allons créer les modules reconfigurables (compteur et décompteur) et
le module statique (afficheur) dans le répertoire "synthese".
1. Sélectionner Démarrer > Programmes > Xilinx ISE Design Suite10.1 > Project
Navigator.
2. Dans Project Navigator, créer un nouveau projet en faisant File > New Project.
3. Entrer Le nom du projet compteur et dans location ajouter \synthese pour créer un
répertoire spécifique à ISE. Puis Cliquer Next.

Figure 8: Création de projet ISE

4. Dans Device Properties, choisir une carte de développement, ici Virtex2P, xc2vp30-6
ff896. Cliquer Next > New source > Sélectionner VHDL Module et saisir le nom du module
ici compteur et cliquer Next.

Figure 9: les paramètres de projet

Eniso 2014-2015 30
3 éme E.I TP3&4

5. Editer ensuite le nom des entrées/Sorties, et leurs caractéristiques (in/out, bus/bit). Cliquer
Next puis Finish.

6. Editer le code VHDL.

Etape 3 : Synthèse.

1. Sélectionner le module et dans la fenêtre de dessous, clic droite sur Synthesize – XST >
Properties > Xlinx Specific Options puis décocher Add I/O Buffers.

Figure 10 : Les propriétés du module avec l’outil XST

2. On voit alors dans la console la synthèse qui s’effectue et le rapport des erreurs et des
warnings. Corriger les erreurs éventuelles, les warnings peuvent être ignorés.

Etape 4 : Simulation.

1. Proposer des stimulus sur les entrées pour vérifier le fonctionnement de module

Répéter la même procédure pour chaque module.

3-2-2 Module global

Le module global est le module top qui contient les différents modules statiques et
reconfigurables. Dans notre manipulation on doit allumer quatre diodes leds en utilisant soit le
compteur avec l’afficheur soit le décompteur avec l’afficheur. En effet, on a deux
Eniso 2014-2015 31
3 éme E.I TP3&4

configurations C1=compteur+Afficheur et C2= décompteur+afficheur. Alors pour réaliser ces

deux configurations, nous allons utiliser deux méthodes : la reconfiguration statique et la
reconfiguration dynamique partielle.

Figure 11 : Module top

3-2-2-1 La reconfiguration statique

Etape 1 : Créer un projet.

Etape 2 : Synthèse.
Etape 3 : Implémentation.

Etape 1 : Créer un projet.

1. Répéter l’étape 2 précédente et ajouter les fichiers ".vhd " nécessaires au projet pour créer
le module top de la première configuration C1.

Etape 2 : Synthèse.

1. Sélectionner le module et dans la fenêtre de dessous, clic droite sur Synthesize – XST >
Properties > Xlinx Specific Options puis cocher Add I/O Buffers.

Etape 3 : Implémentation.

Cette phase consiste à spécifier les pins d’entrées/sorties et les contraintes temporelles (s’il
existe des horloges dans le design) dans un fichier UCF (User Contraints File).

1. Sélectionner le module et dans la fenêtre de dessous, dérouler la plus à côté de User

Contraints. Puis double clic sur Create Timing Constraints, puis cliquer yes.

2. Compléter les champs nécessaires et puis enregistrer le fichier UCF.

Figure 12: Contraintes temporelles

3. Assigner les pins d’entrées/sorties de le FPGA aux ports convenables de design dans notre
cas les 4 diodes leds et l’horloge. En outre, sélectionner le module et dans la fenêtre de

Eniso 2014-2015 32
3 éme E.I TP3&4

dessous, dérouler la plus à côté de User Contraints. Puis, double clic sur Floorplan
Area/ IO/ Logic - Post Synthesis, puis cliquer yes.

4. Saisir les informations de tous les pins. Puis enregistrer et fermer le Floorplanner.

Composant Pin FPGA

Led 0 AC4
Led 1 AC3
Led 2 AA6
Led 3 AA5
Horloge AJ15

Figure 13 : Les pins d’entrées/sorties

5. Implémenter le design sur la carte FPGA et vérifier son fonctionnement.
6. Répéter la même procédure pour la deuxième configuration C2 (décompteur +afficheur).

3-2-2-2 La reconfiguration dynamique partielle

1. Editer le code VHDL du module top comme suit :

 Ajouter le package de bus macro

library work;
use work.busmacro_xc2vp_pkg.all;

Eniso 2014-2015 33
3 éme E.I TP3&4

 Ajouter à chaque composant de module top l’attribut

attribute box_type of nom_component: component is "black_box";

 Ajouter le composant de l’horloge BUFGP

component BUFGP is
port (I : in std_logic;
O : out std_logic);
end component;

 Editer le mappage entre les composants comme indique la figure 15. Ainsi, le bus
macro utilisé est le busmacro_xc2vp_l2r_async_narrow.

Figure 14: Le busmacro_xc2vp_l2r_async_narrow

Figure 15 : Module top pour la RDP

Eniso 2014-2015 34
3 éme E.I TP3&4

2. Sélectionner le module et dans la fenêtre de dessous, clic droite sur Synthesize – XST >
Properties > Synthesis Options > Keep Hierarchy > Yes. Puis au niveau de Cores Search
Directories saisir les différents chemins de chaque module et en fin cliquer ok et Run

3-3 ISE: Implémentation.

Maintenant on passe sous le répertoire implementation pour implémenter le module

global et les modules actifs c’est-à-dire les modules qui constituent la configuration en cours.

3-3-1 Module global

1. Copier le fichier top.ngc de synthese/top à implementation/top_initial.

2. Copier le fichier de bus macro ".nmc" dans implementation/top_initial. et

implementation/top_final

3. Sélectionner Démarrer > Programmes> accessoires > invite de commandes. Changer la

direction vers le répertoire implementation/ top_initial et saisir la commande prompt.

4. Saisir les commandes suivantes :

 ngdbuild –modular initial top.ngc
 floorplanner top.ngd

Figure 16 : Module top pour la RDP

Eniso 2014-2015 35
3 éme E.I TP3&4

Pour placer les modules dans le FPGA il faut utiliser toute la hauteur du FPGA.
Sélectionner le module puis Floorplan>Assign Area Constraint et choisir
l’emplacement du module dans le FPGA. Finalement, enregistrer et fermer le
Floorplanner.

5. Ajouter l’instruction suivante au niveau de fichier ".ucf " pour tous les modules actifs.
AREA_GROUP "AG_nom de module" MODE=RECONFIG;

3-3-2 Les modules actifs

Les modules actifs sont les modules reconfigurables et les modules statiques. Nous allons
commencer par le module compteur et de la même façon on va construire les autres modules.

1. Copier le fichier compteur.ngc de synthese/compteur à implementation/compteur.

2. Copier le fichier top.ucf de implementation/ top_initial à implementation/compteur.

3. Changer le répertoire dans l’Invite de commandes vers le dossier implementation/

compteur.

4. Saisir les commandes suivantes :

 ngdbuild –modular module –active compteur ..\top_initial\top.ngc

 ngdbuild –modular module –active compteur -uc top.ucf ..\top_initial\top.ngc

 map top.ngd

 par –w top.ncd top1.ncd

 fpga_editor top1.ncd // pour placer manuellement le bus macro dans un endroit

bien déterminé et puis enregistrer.

Eniso 2014-2015 36
3 éme E.I TP3&4

Figure 17 : FPGA_Editor de module compteur

 pimcreate –ncd top1.ncd ..\Pim

5. Répéter la même procédure pour chaque module.

3-3-3 Assemblage des modules.

A ce niveau on va assembler les différents modules statiques et dynamiques pour

construire une configuration donnée.

1. Changer le répertoire dans l’Invite de commandes vers le dossier implementation/

top_final.
2. Copier les deux fichiers top.ngc et top.ucf de dossier top_initial à top_final.

Eniso 2014-2015 37
3 éme E.I TP3&4

3. Saisir les commandes suivantes :

 ngdbuild –modular assemble –pimpath ..\Pim –use_pim compteur –use_pim

afficheur top.ngc
 map top.ngd
 par –w top.ncd top_routed.ncd
 fpga_editor top_routed.ncd

Figure 18 : FPGA_Editor de module global top

3-3-4 Création des bitstreams

Dans cette section on va créer les bitstreams total et partiel. Tout d’abord, nous allons
créer le bitstream total pour réaliser la première configuration. Donc on doit saisir la
commande suivante :

bitgen –w top_routed.ncd top_routed.bit

Maintenant, on va créer le bitstream partiel pour la réalisation de la deuxième

configuration.

Eniso 2014-2015 38
3 éme E.I TP3&4

bitgen –g ActiveReconfig:Yes –d top1.ncd top_partial.bit

1. Implementer le bitstream total dans le FPGA.

2. Implementer par la suite le bitstream partiel.

Eniso 2014-2015 39
Annexes
 1- RAMB16_Sm_Sn :
16384-Bit Data Memory and 2048-Bit Parity Memory, Dual-Port Synchronous Block
RAM with Port Width (m or n) Configured to 1, 2, 4, 9, 18, or 36 Bits.

RAMB16_S1_S1 through RAMB16_S1_S36 Representations

RAMB16_S2_S2 through RAMB16_S4_S36 Representations
 RAMB16_S9_S9 through RAMB16_S36_S36 Representations
The RAMB16_Sm_Sn components listed in the following table are dual-ported dedicated
random access memory blocks with synchronous write capability. Each block RAM port has
16384 bits of data memory. Ports configured as 9, 18, or 36-bits wide have an additional 2048
bits of parity memory. Each port is independent of the other while accessing the same set of
16384 data memory cells. Each port is independently configured to a specific data width. The
possible port and cell configurations are listed in the following table.
 Port A Port B

Data Parity Address Data Parity Data Parity Address Data Parity
Component
Cellsa Cellsa Bus Bus Bus Cellsa Cellsa Bus Bus Bus

RAMB16_S1_S1 16384 x 1 - (13:0) (0:0) - 16384 x 1 - (13:0) (0:0) -

RAMB16_S1_S2 16384 x 1 - (13:0) (0:0) - 8192 x 2 - (12:0) (1:0) -

RAMB16_S1_S4 16384 x 1 - (13:0) (0:0) - 4096 x 4 - (11:0) (3:0) -

RAMB16_S1_S9 16384 x 1 - (13:0) (0:0) - 2048 x 8 2048 x 1 (10:0) (7:0) (0:0)

RAMB16_S1_S18 16384 x 1 - (13:0) (0:0) - 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)

RAMB16_S1_S36 16384 x 1 - (13:0) (0:0) - 512 x 32 512 x 4 (8:0) (31:0) (3:0)

RAMB16_S2_S2 8192 x 2 - (12:0) (1:0) - 8192 x 2 - (12:0) (1:0) -

RAMB16_S2_S4 8192 x 2 - (12:0) (1:0) - 4096 x 4 - (11:0) (3:0) -

RAMB16_S2_S9 8192 x 2 - (12:0) (1:0) - 2048 x 8 2048 x 1 (10:0) (7:0) (0:0)

RAMB16_S2_S18 8192 x 2 - (12:0) (1:0) - 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)

RAMB16_S2_S36 8192 x 2 - (12:0) (1:0) - 512 x 32 512 x 4 (8:0) (31:0) (3:0)

RAMB16_S4_S4 4096 x 4 - (11:0) (3:0) - 4096 x 4 - (11:0) (3:0) -

RAMB16_S4_S9 4096 x 4 - (11:0) (3:0) - 2048 x 8 2048 x 1 (10:0) (7:0) (0:0)

RAMB16_S4_S18 4096 x 4 - (11:0) (3:0) - 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)

RAMB16_S4_S36 4096 x 4 - (11:0) (3:0) - 512 x 32 512 x 4 (8:0) (31:0) (3:0)

RAMB16_S9_S9 2048 x 8 2048 x 1 (10:0) (7:0) (0:0) 2048 x 8 2048 x 1 (10:0) (7:0) (0:0)

RAMB16_S9_S18 2048 x 8 2048 x 1 (10:0) (7:0) (0:0) 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)

RAMB16_S9_S36 2048 x 8 2048 x 1 (10:0) (7:0) (0:0) 512 x 32 512 x 4 (8:0) (31:0) (3:0)

RAMB16_S18_S18 1024 x 16 1024 x 2 (9:0) (15:0) (1:0) 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)

RAMB16_S18_S36 1024 x 16 1024 x 2 (9:0) (15:0) (1:0) 512 x 32 512 x 4 (8:0) (31:0) (3:0)

RAMB16_S36_S36 512 x 32 512 x 4 (8:0) (31:0) (3:0) 512 x 32 512 x 4 (8:0) (31:0) (3:0)

Each port is fully synchronous with independent clock pins. All port A input pins have
setup time referenced to the CLKA pin and its data output bus DOA has a clock-to-out time
referenced to the CLKA. All port B input pins have setup time referenced to the CLKB pin
and its data output bus DOB has a clock-to-out time referenced to the CLKB.
The enable ENA pin controls read, write, and reset for port A. When ENA is Low, no data
is written and the outputs (DOA and DOPA) retain the last state. When ENA is High and reset
(SSRA) is High, DOA and DOPA are set to SRVAL_A during the Low-to-High clock
(CLKA) transition; if write enable (WEA) is High, the memory contents reflect the data at
DIA and DIPA. When ENA is High and WEA is Low, the data stored in the RAM address
(ADDRA) is read during the Low-to-High clock transition. By default,
WRITE_MODE_A=WRITE_FIRST, when ENA and WEA are High, the data on the data
inputs (DIA and DIPA) is loaded into the word selected by the write address (ADDRA)
during the Low-to-High clock transition and the data outputs (DOA and DOPA) reflect the
selected (addressed) word.
The above descriptions assume active High control pins (ENA, WEA, SSRA, CLKA, ENB,
WEB, SSRB, and CLKB). However, the active level can be changed by placing an inverter on
the port. Any inverter placed on a RAMB16 port is absorbed into the block and does not use a
CLB resource.
Inputs Outputs

GSR ENA SSRA WEA CLKA ADDRA DIA DIPA DOA DOPA RAM Contents

Data RAM Parity RAM

1 X X X X X X X INIT_A INIT_A No Chg No Chg

0 0 X X X X X X No Chg No Chg No Chg No Chg

0 1 1 0 X X X SRVAL_A SRVAL_A No Chg No Chg

0 1 1 1 addr data pdata SRVAL_A SRVAL_A RAM(addr) =>data RAM(addr) =>pdata

0 1 0 0 addr X X RAM(addr) RAM(addr) No Chg No Chg

No Chg1 No Chg1
0 1 0 1 addr data pdata RAM (addr) RAM(addr)2 RAM(addr) =>data RAM(addr) =>pdata
2

data3 pdata3

GSR=Global Set Reset

INIT_A=Value specified by the INIT_A attribute for output register. Default is all zeros.
SRVAL_A=register value
addr=RAM address
RAM(addr)=RAM contents at address ADDR
data=RAM input data
pdata=RAM parity data
1
WRITE_MODE_A=NO_CHANGE
2
WRITE_MODE_A=READ_FIRST
3
WRITE_MODE_A=WRITE_FIRST

2- Afficheur 7 segments :
 3- Diodes LEDS :

4- Boutons poussoirs :

5- Switcheurs :

6- Horloge :

View publication stats