<<

Conception et VHDL

>>

L'objectif de ce chapitre est d'introduire rapidement les notions matérielles pour les circuits simples programmables ou PLA. Les documentations de ces circuits peuvent encore être appréhendées par des schémas logiques simples, mais ce ne sera plus le cas si l'on désire s'intéresser aux Complex Programmable Logic Devices ou aux FPGA. Nous aborderons aussi quelques notions liées aux FPGA en fin de chapitre. En ce qui nous concerne, seules ces notions sont enseignées maintenant.

Généralités

Nous commençons par présenter les conventions de la représentation des circuits programmables : regardez l'image ci-dessous avec à gauche la convention schématique habituelle et à droite la nouvelle convention.

Convention des schémas internes des composants logiques programmables

On voit sur cette image que les entrées des portes ET sont, par convention, ramenées sur un fil. Pour connaître le nombre d'entrées des portes ET ainsi dessinées, il vous faut compter le nombre d'intersections avec des fils perpendiculaires et de diviser par deux. Par exemple sur l'image, le fil d'entrée (vertical) de la porte ET de gauche rencontre 6 fils (horizontaux), ce qui signifie que la porte ET comporte trois entrées (ce qui correspond bien au schéma de gauche). Une division par deux est réalisée car en général il arrive la variable et son complément.

Nous avons utilisé ici la même convention pour le OU logique qui suit le ET. Mais, en général, pour les circuits simples, on dessine toutes les entrées des OU comme ce sera fait dans les schémas internes décrits plus loin dans ce chapitre.

Les croix indiquent les liaisons sur des fils qui se croisent. Cette convention n'est utile qu'avec les circuits programmables simples (PLD, PAL et PLA)

Remarque : un réseau PLA ne contient que rarement tous les "minterms" (termes produits) contrairement à une mémoire. Dans l'exemple de la figure ci-dessus, le fait que le OU ne contient que 4 entrées veut dire que seulement quatre termes produits sont réalisables simultanément. Pourtant, avec trois entrées, il existe huit termes produits.

Correspondance entre les variables logiques et les broches physiques

Lors de la programmation de composants, il nous faut établir une correspondance entre les variables logiques déclarées dans l'entité et les broches physiques d'un composant. Il existe plusieurs techniques pour cela :

Avec Warp2 (Cypress) on utilise un attribut :

ATTRIBUTE pin_numbers of mydesign:ENTITY IS
	"x:1 y:2 clk:3 a(0):4 ";

avant de fermer la déclaration d'entité (qui s'appelle dans ce cas "mydesign"). Cette façon de faire est très peu portable.

Avec Xilinx on utilise un fichier séparé (appelé fichier ucf voir exemple ici). C'est un peu plus adapté aux FPGA qui ont facilement un nombre de broches important (supérieur à 256).

Nomenclature des circuits programmables

Les circuits programmables ont des noms dans lesquels au moins deux chiffres apparaissent séparés par une ou plusieurs lettres.

le premier chiffre donne le nombre d'entrées des ET logiques utilisés,
le dernier chiffre donne en général le nombre de sorties. Si ce nombre N est inférieur à 8, il y aura 8 sorties en tout dont N qui seront de type déterminé par la lettre,
la lettre sera L pour combinatoire, R pour logique séquentielle, V pour Versatile que l'on peut traduire par configurable.

Remarque : sachant que la représentation des entrées des portes ET se fait toujours par un seul fil horizontal, le premier chiffre multiplié par deux indiquera toujours le nombre de fil vertical rencontrés par ce fil horizontal.

Appliquons tout ceci à la PAL 16R4 présentée ci-dessous :

Son nom indique que l'on 4 sorties séquentielles, ce qui n'est pas difficile à remarquer. Ces sorties sont complétées par 4 sorties combinatoires.

Les 64 termes produits indiqués sur la figure sont répartis à égalité sur les 8 sorties, ce qui indique que les OU ont tous 8 entrées.

Exercice 1

On veut réaliser le circuit schématisé ci-contre dans une PAL 16R8 dont le schéma partiel est présenté ci-dessous. Écrire le programme VHDL correspondant en remarquant que la variable Ena n'a pas besoin d'être déclarée dans l'entité. Placez les croix correspondantes au programme sur le schéma ci-après.

Remarque : même si cette structure (ci-dessous) avec OU à nombre d'entrées fixé est appelée PAL, on utilisera indifféremment dans la suite PAL ou PLA.

Remarque : La PAL étant une 16R8, le schéma ci-dessus est incomplet : il manque 7 sorties et aussi 28 fils verticaux (2 x 16 moins les 4 que l'on a).

Indication : transformez votre schéma en équation de récurrence. Ce qui se trouve avant Qout dans le schéma original est une commande trois états sans inversion. Quand vous essayez d'implanter votre équation partez de la sortie physique de votre PAL.

Solution de l'exercice 1 ci-dessus

Le schéma initial donne $Q^{+}=D=Toggle.{\overline {Q}}$

Mais le schéma de la 16R8 nous montre immédiatement que ce n'est pas Q+ qu'il nous faut réaliser mais /Q+ à cause de l'inverseur présent sur la sortie. Si $Q_{o}ut$ est notre sortie, ${\overline {Q_{o}ut}}$ sera notre sortie de la bascule 16R8, et donc l'entrée D sera :

$D={\overline {Q_{out}^{+}}}$ .

Notre équation de récurrence est donc transformée en :

$D={\overline {{Q^{+}}_{out}}}=Toggle.{\overline {Q}}=Toggle.Qout$ car $Qout={\overline {Q}}$

Ce qui donne le schéma suivant :

Pour changer de champ d'application voici un exercice concernant l'arithmétique élémentaire.

Exercice 2 (PAL 16X4 spécialisé pour arithmétique)

On vous présente le contenu partiel d'une PAL 16X4 destinée à réaliser des opérations arithmétiques.

Remarque : La PAL étant une 16X4, le schéma ci-dessus est incomplet : il manque 6 sorties et aussi 24 fils verticaux (2 x 16 moins les 8 que l'on a).

1°) La cellule de base d'un PAL destiné à l'arithmétique est donnée ci-dessus. Repérer et exprimer les valeurs logiques des fils internes 8, 9, 10 et 11 en fonction de A1 et B1. A quoi sert I ?

2°) On cherche à utiliser ce genre de cellule pour réaliser une addition 1 bit : $(C_{1}A_{1}^{+})_{2}=(A_{1})_{2}+(B_{1})_{2}+(C_{0})_{2}$ . On rappelle les équations de C1 et A1+

C1 = (A1 xor B1).C0 + A1.B1

A1+ = A1 xor B1 xor C0

En déduire les équations de S1= $/A_{1}^{+}$ (sous forme de ou exclusifs et/ou fonctions identités) et de /C1 (sous forme disjonctive).

3°) Calculs intermédiaires : calculer les produits (fonctions ET logique) (8).(9), (9).(11), (9).(10), (8).(11), (8).(9).(11) et (8).(10).(11) et montrer qu'ils interviennent tous dans les équations précédentes de S1 et de /C1.

4°) Dessiner les fusibles non grillés sur la figure ci-dessus.

Solution de l'exercice 2 ci-dessus

1°) (8)=(B1 + /A1), (9)=(/B1 + /A1), (10)=(B1+A1) et (11)=(/B1 + A1)

I est une commande de sortie 3 états (pour mettre en haute impédance)

2°) S1 = /(A1+) = (A1 identité B1) xor C0 ${\overline {C_{1}}}={\overline {(A_{1}xorB_{1})\cdot C_{0}+A_{1}\cdot B_{1}}}={\overline {(A_{1}xorB_{1})\cdot C_{0}}}\cdot {\overline {A_{1}\cdot B_{1}}}=({\overline {(A_{1}xorB_{1})}}+{\overline {C_{0}}})\cdot ({\overline {A}}_{1}+{\overline {B}}_{1})$

soit ${\overline {C}}_{1}={\overline {A}}_{1}\cdot {\overline {B}}_{1}+{\overline {C}}_{0}\cdot {\overline {A}}_{1}+{\overline {C}}_{0}\cdot {\overline {B}}_{1}$

3°) (8)(9)=/A1, (9)(10) = A1 xor B1, (8).(11) = A1 identité B1, (9).(11)= /B1 (8)(9)(11)=/A1./B1,

Nous allons maintenant nous intéresser aux nouvelles catégories de composants programmables, ceux qui utilisent des cellules "versatiles" (configurables) et que l'on appelle parfois GAL.

La GAL 20V8

On présente ci-dessous le schéma partiel du circuit de la GAL 20V8 (24 broches dont 8 sorties configurables).

On peut distinguer 13 entrées véritables notées de I1 à I13. Chaque sortie est notée de I/O0 à I/O7. La notation laisse penser, à juste titre, que si l'on manque d'entrée, on peut transformer des sorties en entrées. Si vous n'avez pas d'horloge (en logique combinatoire par exemple), vous pouvez aussi utiliser la broche CLK/I0 en entrée.


Définition
On appelle cellule configurable, un cellule, c'est à dire un ensemble de circuits, dont le fonctionnement est conditionné par des bits internes. Cet ensemble de circuits représente le schéma interne de la cellule qui suffit, en général, à expliquer son fonctionnement.

Chaque sortie est constituée par une cellule configurable à l'aide de bits internes. Le schéma de cette cellule configurable est donné ci-dessous :

On peut y distinguer des multiplexeurs, commandés par les bits SG1 et SL0x (où x est le numéro de la sortie correspondante), un ou exclusif commandé par un bit SL1x. L'objectif de ce ou exclusif est de complémenter ou pas la sortie du ou logique qui le précède.


Définition
On appelle bit global tout bit dont la deuxième lettre du nom est "G". On appelle bit local tout bit dont la deuxième lettre du nom est un "L".

Un bit global est forcément identique pour les 8 cellules configurables. Un bit local est dépendant de la macrocellule, et c'est pour cela qu'il est terminé par un x.

Pour terminer sur ce composant on donne un schéma interne partiel où l'on reconnaît ces cellules configurables :

Remarque : La PAL étant une 20V8, le schéma ci-dessus est incomplet : il manque 4 sorties et aussi 16 fils verticaux (2 x 20 moins les 24 que l'on a).

La GAL 22V10

La GAL 22V10 est plus récente que la 20V8. On pourrait penser que la cellule configurable de ce composant est plus complexe que celle de la 20V8, puisque plus moderne, mais il n'en est rien. Nous commençons par présenter cette cellule configurable :

On distingue sur ce schéma une simplification sur les entrées du OU logique à l'aide de pointillés. Cela est dû au fait que le nombre de ET logique arrivant sur le OU logique est variable suivant la cellule configurable : les broches 14 et 23 ont en 8, les broches 15 et 22 ont en 10, les broches 21 et 16 ont en 12, les broches 17 et 20 ont en 14 et enfin les broches 18 et 19 ont en 16. Le nombre de multiplexeurs a franchement diminué (en taille comme en nombre) ce qui facilite sa compréhension.

Voici un exemple de composant 22V10 :

Le brochage de ce composant est donné par la figure ci-dessous :

On présente maintenant un schéma interne partiel de ce composant :

Schéma interne partiel d'un composant 22V10

Remarque : La PAL étant une 22V10, le schéma ci-dessus est incomplet : il manque 6 sorties et aussi 28 fils verticaux (2 x 22 moins les 16 que l'on a).

Le schéma interne complet est complexe et peut être simplifié comme sur la figure ci-dessous :

Exercice 3

La polarité de chaque cellule configurable peut être programmée individuellement pour être inversée ou non. D'autre part la sortie peut être combinatoire ou séquentielle.

1°) Lequel des deux bits bits (S0 et S1) détermine la polarité ?

2°) Dessinez les quatre circuits équivalents à la cellule configurable.

Solution partielle de l'exercice 3 ci-dessus

1°) C'est S0 qui détermine la polarité : quand il passe de 0 à 1 on complémente tout.

Les CPLD

Un CPLD peut être défini comme un assemblage de PLDs de type 22V10. Nous en donnons la structure ci-dessous :

Tous les "Logic Blocs" sont à peu près équivalents à des PALs 22V10. Comme on peut le voir, ces PALs sont connectées par le bloc "Programmable Interconnect". Dans cette architecture une implantation ne nécessite pas de placements et routages mais seulement des interconnexions.

Les FPGA

Les FPGA sont des composants plus complexes encore que les CPLD. Nous allons examiner quelques unes de leurs particularités à travers des exemples d'implantation.

Les LUTs

Les LUTs sont des éléments importants des FPGA. Nous allons essayer de les manipuler en VHDL.

Présentation des LUTs

Une table de vérité de trois entrées peut être représentée par un nombre 8 bits que l'on convertit en hexadécimal. Soit donc la table de vérité suivante (trois entrées notées e0, e1 et e2, une sortie notée s) :

e2	e1	e0	s
0	0	0	0	b₀
0	0	1	1	b₁
0	1	0	1	b₂
0	1	1	0	b₃
1	0	0	1	b₄
1	0	1	0	b₅
1	1	0	1	b₆
1	1	1	0	b₇

Vous pouvez synthétiser la table de vérité à l'aide d'un seul nombre sur 8 bits (poids faible en haut) :

en binaire ce nombre vaut : 0b01010110
en hexadécimal ce nombre vaut : 0x56 (noté X"56" en VHDL)

La valeur hexadécimale 56 (notée X"56" en VHDL) est la valeur avec laquelle il faudra initialiser votre LUT avec un composant lut3.

Pour 4 entrées (ce qui est notre cas), on utilise une lut4 avec 4 chiffres hexadécimaux.

Utiliser des LUTs en VHDL

Cette section est malheureusement spécifique au fabricant Xilinx.

Un exemple est donné maintenant :

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
library unisim; 
use unisim.vcomponents.all;
ENTITY transcodeur IS PORT(
  e : in STD_LOGIC_VECTOR(3 DOWNTO 0);   -- 4 entrées
  s : out STD_LOGIC_VECTOR(6 DOWNTO 0)); -- 7 sorties
END transcodeur;
ARCHITECTURE atranscodeur OF transcodeur IS BEGIN
i1 : LUT4 
  generic map (INIT => X"EAAA") 
  port map( I0 => e(0), 
            I1 => e(1), 
            I2 => e(2), 
            I3 => e(3), 
             O => s(0) );
.....

Cet exemple vous montre comment on câble une LUT4 en VHDL (port map) et comment on l'initialise (generic map). Le câblage de ce composant est correct mais pas son initialisation puisqu'on vous demande de la calculer plus loin. Les deux lignes library ... et use ... sont à ajouter avant toute entité qui utilise une LUT en plus bien sûr de "library ieee;".

Exercice 4

Réaliser le schéma correspondant au "port map" de l'exemple ci-dessus dans le composant "transcodeur" (deux rectangles, un appelé "transcodeur" et un appelé "LUT4").

Compléter ce schéma avec d'éventuels pointillés en montrant que sept LUTs seront nécessaires pour réaliser le transcodeur complet.

Réaliser une table de vérité complète du décodage demandé.

En déduire les 7 valeurs hexadécimales d'initialisation des LUTs.

Réaliser l'architecture complète de "transcodeur".

Solution de l'exercice 4

-- Xilinx specific
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
library unisim; 
use unisim.vcomponents.all;
ENTITY transcodeur IS PORT(
  e : in STD_LOGIC_VECTOR(3 DOWNTO 0);   -- 4 entrées
  s : out STD_LOGIC_VECTOR(6 DOWNTO 0)); -- 7 sorties
END transcodeur;
ARCHITECTURE atranscodeur OF transcodeur IS BEGIN
i1 : LUT4 -- segment a
  generic map (INIT => X"D7ED") 
  port map( I0 => e(0), 
            I1 => e(1), 
            I2 => e(2), 
            I3 => e(3), 
             O => s(0) );
i2 : LUT4 -- segment b
  generic map (INIT => X"279F") 
  port map( I0 => e(0), 
            I1 => e(1), 
            I2 => e(2), 
            I3 => e(3), 
             O => s(1) );
i3 : LUT4 -- segment c
  generic map (INIT => X"2FFB") 
  port map( I0 => e(0), 
            I1 => e(1), 
            I2 => e(2), 
            I3 => e(3), 
             O => s(2) );
i4 : LUT4 -- segment d
  generic map (INIT => X"7B6D") 
  port map( I0 => e(0), 
            I1 => e(1), 
            I2 => e(2), 
            I3 => e(3), 
             O => s(3) );
i5 : LUT4 -- segment e
  generic map (INIT => X"FD45") 
  port map( I0 => e(0), 
            I1 => e(1), 
            I2 => e(2), 
            I3 => e(3), 
             O => s(4) );
i6 : LUT4 -- segment f
  generic map (INIT => X"DF71") 
  port map( I0 => e(0), 
            I1 => e(1), 
            I2 => e(2), 
            I3 => e(3), 
             O => s(5) );
i7 : LUT4 -- segment a
  generic map (INIT => X"EF7C") 
  port map( I0 => e(0), 
            I1 => e(1), 
            I2 => e(2), 
            I3 => e(3), 
             O => s(6) );
end atranscodeur;

RAM et FPGA

La nomination de la mémoire dans un FPGA n'est pas très simple : s'agit-il de RAM ou de ROM ? La documentation parle de RAM mais comme il est possible de l'initialiser lors de son écriture en VHDL, on peut facilement l'utiliser comme une ROM. C'est naturellement ce que l'on fait lorsque l'on implante un processeur dans le FPGA pour lui donner un programme à exécuter (voir livre sur SOC (System on Chip)).

Il est possible de réaliser des protocoles pour charger cette mémoire à partir des fichiers HEX (Intel) ou binaire comme ce sera développé dans le chapitre Programmer in Situ et déboguer du livre précédemment cité.

La BRAM ou bloc RAM

Les mémoires sont difficiles à utiliser en VHDL car la façon pour les implémenter dépend du fondeur de FPGA. Ainsi la façon de faire présentée dans cette section n'est vraie que pour les FPGA Xilinx.

Si vous voulez que votre outil de synthèse infère une RAM/ROM il vous faut écrire votre RAM/ROM avec un style spécifique. Nous présentons ici un exemple sur lequel nous nous appuierons dans la suite : ROM avec sortie Registered

-- 
-- ROMs Using Block RAM Resources. 
-- VHDL code for a ROM with registered output (template 1) 
-- 
library ieee; 
use ieee.std_logic_1164.all; 
use ieee.std_logic_unsigned.all; 
entity rams_21a is 
    port (clk : in std_logic; 
           en    : in std_logic; 
           addr : in std_logic_vector(5 downto 0); 
           data : out std_logic_vector(19 downto 0)); 
end rams_21a; 
architecture syn of rams_21a is 
  type rom_type is array (63 downto 0) of std_logic_vector (19 downto 0); 
  signal ROM : rom_type:= 
    (X"0200A", X"00300", X"08101", X"04000", X"08601",   X"0233A", 
     X"00300", X"08602", X"02310", X"0203B", X"08300", X"04002", 
     X"08201", X"00500", X"04001", X"02500", X"00340", X"00241", 
     X"04002", X"08300", X"08201", X"00500", X"08101", X"00602", 
     X"04003", X"0241E", X"00301", X"00102", X"02122", X"02021", 
     X"00301", X"00102", X"02222", X"04001", X"00342", X"0232B", 
     X"00900", X"00302", X"00102", X"04002", X"00900", X"08201", 
     X"02023", X"00303", X"02433", X"00301", X"04004", X"00301", 
     X"00102", X"02137", X"02036", X"00301", X"00102", X"02237", 
     X"04004", X"00304", X"04040", X"02500", X"02500", X"02500", 
     X"0030D", X"02341", X"08201", X"0400D"); 
begin 
    process (clk) 
    begin 
        if (clk'event and clk = '1') then 
             if (en = '1') then 
                  data <= ROM(conv_integer(addr)); 
             end if; 
         end if; 
    end process; 
end syn;

Exercice 5 (spécifique Xilinx et carte Spartan3)

Compteur à sortie sept segments réalisé avec une mémoire

Nous allons utiliser un compteur normal, c'est à dire qui compte en binaire sur 4 bits suivi d'une mémoire pour le transcodage pour l'affichage sur un afficheur sept segments.

Dimensionner la ROM nécessaire à votre problème. Calculer les valeurs hexadécimales contenues dans cette ROM.

Réaliser un compteur 4 bits avec initialisation asynchrone.
Réaliser un diviseur de fréquence par 2**24
Assembler le tout

Solution de l'exercice 5

library ieee;
use ieee.std_logic_1164.all;
entity top is port (
  clk_50Mhz : in std_logic;
  aff : out std_logic_vector(3 downto 0);
  s_7segs : out std_logic_vector(6 downto 0));
end top;
architecture atop of top is
  component rams_21a is
    port (clk : in std_logic;
           en    : in std_logic;
           addr : in std_logic_vector(3 downto 0);
           data : out std_logic_vector(7 downto 0));
  end component;
  component div is
  port( clk_50Mhz : in std_logic;
        clk_slow : out std_logic);
  end component;
  component cmpt4bits is
  port( clk,en : in std_logic;
        q : out std_logic_vector(3 downto 0));
  end component;
  signal s_clk_slow, s_d : std_logic;
  signal s_addr : std_logic_vector(3 downto 0);
  signal sig_7segs : std_logic_vector(6 downto 0);
begin
  i1 : div  port map(clk_50Mhz => clk_50Mhz,clk_slow => s_clk_slow);
  i2 : cmpt4bits port map(clk => s_clk_slow,q => s_addr,en => '1');
  i3 : rams_21a port map(clk => clk_50Mhz,addr => s_addr,data(6 downto 0) => sig_7segs,
                        data(7) => s_d, en => '1');
  s_7segs	<= not sig_7segs;		-- remove the not if segment display with '1'					
  aff(0) <='0';
  aff(1) <='1';
  aff(2) <='1';
  aff(3) <='1';
end atop;

--ROM With Registered Output VHDL Coding Example One
--
-- ROMs Using Block RAM Resources.
-- VHDL code for a ROM with registered output (template 1)
--
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity rams_21a is
    port (clk : in std_logic;
           en    : in std_logic;
           addr : in std_logic_vector(3 downto 0);
           data : out std_logic_vector(7 downto 0));
end rams_21a;
architecture syn of rams_21a is
    type rom_type is array (0 to 15) of std_logic_vector (7 downto 0);
	 -- transcodage hexadécimal affiche 0 à F
    signal ROM : rom_type:= (X"3F", X"06", X"5B", X"4F", X"66", X"6D", X"7D", X"07", 
	                          X"7F", X"6F", X"77", X"7C", X"39", X"5E", X"79", X"71");
begin
    process (clk)
    begin
        if (clk'event and clk = '1') then
             if (en = '1') then
                  data <= ROM(conv_integer(addr));
             end if;
         end if;
    end process;
end syn;

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity div is
  port( clk_50Mhz : in std_logic;
        clk_slow : out std_logic);
end div;
architecture adiv of div is 
signal cmpt : std_logic_vector(23 downto 0);
begin
  process(clk_50MHz) begin
    if rising_edge(clk_50Mhz) then
      cmpt <= cmpt + 1;
    end if;
  end process;
  clk_slow <= cmpt(23);
end adiv;

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity cmpt4bits is
  port( clk,en : in std_logic;
        q : out std_logic_vector(3 downto 0));
end cmpt4bits;
architecture acmpt4bits of cmpt4bits is 
signal s_q : std_logic_vector(3 downto 0);
begin
  process(clk) begin
    if rising_edge(clk) then
	   if en = '1' then
        s_q <= s_q + 1;
		end if;  
    end if;
  end process;
  q <= s_q;
end acmpt4bits;

Commentaires sur l'exercice 5 (spécifique Xilinx)

Votre fichier rapport de compilation doit faire apparaître une ROM : dans "detailed reports" chercher "Synthesizing Unit <rams_21a>", et vous verrez :

WARNING:Xst:1781 - Signal <ROM> is used but never assigned. Tied to default value.
Found 16x8-bit ROM for signal <$varindex0000> created at line 62.
Found 8-bit register for signal <data>.
Summary:
inferred 1 ROM(s).
inferred 8 D-type flip-flop(s).
Unit <rams_21a> synthesized.

Malheureusement, le fait qu'il détecte une ROM à ce point n'est pas suffisant pour être sûr qu'il l'implante tel quel (je veux dire en BRAM). Si vous voulez forcer une BRAM donc, dans la fenêtre "Design",

il faut bien cliquer bouton droit sur "Synthesize -XST".
Mais ensuite il faut sélectionner "Process properties" (et pas "design goals and strategies" ).
Là il faut sélectionner "HDL options" dans la "fenêtre" "Category" .
Et ensuite cocher "rom extract" et pour "rom style" sélectionner "block".

On peut voir le résultat en démarrant PlanAhead (un exemple provenant d'un autre projet est montré ci-dessous) après le placement routage complet de l'application (avec un fichier de contraintes .UCF) depuis la même fenêtre "Design" en développant l'arborescence de "Place and Route" et en lançant "Analyze Timing / Floorplan Design (PlanAhead)".

Les blocs mémoires utilisés dans le FPGA

Les blocs mémoires utilisés sont dessinés en blanc. L'ensemble des blocs disponibles est représenté par les 12 rectangles rouges dont la taille et le nombre dépendent très fortement du type du FPGA utilisé. Nous croyons qu'il est bon de s'habituer à ce genre d'outil pour bien comprendre ce que l'on fait. Il existe même des situations (pas très fréquentes) pour lesquelles l'utilisation de PlanAhead est quasiment obligatoire.

Dans PlanAhead, on ne voit pas forcément le chevelu et les blocs utilisés par l'application. Il faut être sur l'onglet "Device" et cliquer sur les 3 icônes (bande verticale d'icônes à côté du dessin du circuit) "show/hide loc constraints" "show/hide bundle nets" et "show/hide I/O nets".

La RAM distribuée

La RAM distribuée est plus facile à utiliser : il suffit de prendre l'exercice 5 sans choisir les options pour réaliser une BRAM et c'est tout. Nous présentons ci-dessous un exemple qui utilise de la ROM distribuée.

Les blocs mémoires distribués utilisés dans le FPGA

Cet exemple provient d'un autre projet sur VHDL. On distingue encore les rectangles rouges représentant les BRAM non utilisés. L'ensemble des blocs utilisés se trouve encore en blanc et cet exemple montre bien pourquoi on appelle cela de la ROM distribuée.

TD1 VHDL

<<

Conception et VHDL

>>

TD3 VHDL Compteurs et registres