Upload
others
View
7
Download
0
Embed Size (px)
Citation preview
Technologie des circuits intégrés FPGA Bsiss Mohammed
1
Département Génie Électrique
Technologie des circuits numériques FPGA &
Le langage VHDL
Technologie des circuits intégrés FPGA Bsiss Mohammed
2
Préface
Ce manuscrit a pour but de fournir les connaissances nécessaires sur les circuits
numériques intégrés FPGA et le langage de programmation du matériel VHDL pour
les étudiants de la Faculté de Sciences et Techniques de Tanger.
Dans ce manuscrit on va clarifier le langage VHDL pour la conception des systèmes
numériques, aussi bien au niveau comportemental que structurel.
Ce manuscrit n’est pas une référence complète de tous les éléments des circuits
intégrés et leur langage de description matériel VHDL.
Technologie des circuits intégrés FPGA Bsiss Mohammed
3
Sommaire
Préface ....................................................................................................................... 2
Sommaire .................................................................................................................. 3
1 Introduction ....................................................................................................... 5
2 Langage VHDL ................................................................................................... 6
2.1 Les principales caractéristiques du langage VHDL ...................................... 6
2.1.1 Un langage couvrant plusieurs niveau de description ........................... 6
2.1.2 La portabilité .......................................................................................... 7
2.1.3 La lisibilité .............................................................................................. 8
2.1.4 La modularité ........................................................................................ 8
2.2 Entité et Architecture .................................................................................... 8
2.3 Signaux et variables ................................................................................... 12
2.4 Type de données ........................................................................................ 12
2.4.1 Types simples ..................................................................................... 14
2.4.2 Types énumérés ................................................................................. 14
2.4.3 Les types intégraux ............................................................................. 14
2.4.4 Les types physiques ............................................................................ 14
2.4.5 Types tableaux .................................................................................... 15
2.5 Les opérateurs logiques ............................................................................. 15
2.5.1 Attribute ............................................................................................... 16
2.6 Fonctionnement séquentiel ........................................................................ 16
2.7 Processus concurrent ................................................................................. 17
2.8 Instructions composites .............................................................................. 18
2.9 Loop ........................................................................................................... 19
2.1 Instructions contextuelles ........................................................................... 19
2.1 La synthèse ................................................................................................ 20
2.1.1 Le but de la synthèse .......................................................................... 20
2.1.2 Exemples commentés de circuits logiques portes combinatoires ....... 22
2.1.3 Exemples commentés de circuits logiques multiplexeurs ................... 24
3 Les logiques programmables (FPGA/PLD) ................................................... 31
3.1 Introduction ................................................................................................ 31
3.2 Technologie utilisée pour les interconnexions ............................................ 33
3.2.1 Interconnexion directe ......................................................................... 34
3.2.2 Interconnexion par cellule mémoire .................................................... 35
3.3 Architecture de Xilinx FPGA Spartan-3 ...................................................... 37
3.3.1 Caractéristiques générales .................................................................. 37
3.3.2 Réalisation de la logique combinatoire ................................................ 39
Technologie des circuits intégrés FPGA Bsiss Mohammed
4
3.3.3 Les blocs logiques configurables (CLB) .............................................. 40
3.3.4 Blocs d’entrée / de sortie (IOBS) ......................................................... 43
3.3.5 Mémoire FPGA ................................................................................... 44
3.3.6 Multiplexeur ......................................................................................... 46
3.3.7 Gestionnaire d’horloges ...................................................................... 47
4 Modélisation et Synthèse VHDL d’un processeur de traitement du signal 49
4.1 Architecture interne .................................................................................... 49
4.1.1 Unité arithmétique logique (ALU) ........................................................ 50
4.1.2 Registres ............................................................................................. 52
4.1.3 Le système de bus .............................................................................. 53
4.1.4 La mémoire principale (RAM) .............................................................. 55
5 Le processeur étudié ...................................................................................... 56
5.1 Le projet de l'unité arithmétique logique (ALU) ........................................... 58
5.2 Disposition du compteurd´instructions, du registre de commandes et du
multiplexeur ........................................................................................................... 69
5.3 Conception d’une unité de contrôle ............................................................ 73
5.4 Conception de la RAM ............................................................................... 77
5.5 Conception du systeme complet ................................................................ 80
5.5.1 La structure de commande.................................................................. 81
5.5.2 La commande de décodage ................................................................ 82
5.5.3 L'exécution de commandes ................................................................. 83
5.6 La simulation du système complet ............................................................. 85
5.7 Liste des figures ......................................................................................... 87
5.8 Liste des tableaux ...................................................................................... 89
Technologie des circuits intégrés FPGA Bsiss Mohammed
5
1 Introduction
Le langage de description du matérielle VHDL est un langage formel pour la
réalisation des circuits intégrés numériques aussi bien au niveau comportemental
que structurel. VHDL sont les initiales de VHSIC Hardware Description Langage,
VHSIC étant celles de Very High Scale Integrated Circuit. Autrement dit, VHDL
signifie : langage de description matériel s'appliquant aux circuits intégrés à très forte
intégration.
L'évolution des technologies induit une complexité croissante des circuits intégrés qui
ressemblent de plus en plus aux systèmes complets d'hier. Aujourd'hui, on intègre
dans une puce ce qui occupait une carte entière il y a quelques années. La
simulation logique globale du système au niveau "porte" n'est plus envisageable en
terme de temps de simulation. C'est donc tout naturellement que des simulateurs
fonctionnels ont commencé à être utilisés en microélectronique. Dans les années 70,
une grande variété de langages et de simulateurs était utilisée. Cette diversité avait
pour conséquence une non portabilité des modèles et donc une impossibilité
d'échange entre les sociétés. Un des rôles de VHDL est de permettre l'échange de
descriptions entre concepteurs. Ainsi peuvent être mises en place des méthodologies
de modélisation et de description de bibliothèques en langage VHDL. L'effort de
standardisation d'un langage tel que VHDL était nécessaire par le fait qu'il ne
s'agissait pas de construire un seul simulateur VHDL (contrairement à la quasi-
totalité des autres langages), mais de permettre l'apparition d'une multitude d'outils
(de simulation, de vérification, de synthèse, ...) de constructeurs différents utilisant la
même norme. Ceci garantit une bonne qualité (la concurrence) et l'indépendance de
l'utilisateur vis à vis des constructeurs de ces outils.
Technologie des circuits intégrés FPGA Bsiss Mohammed
6
2 Langage VHDL
Dans ce chapitre, les principaux éléments du langage VHDL seront traités.
Le langage VHDL est l'un des langages de modélisation utilisée pour la description et
la simulation des systèmes numériques.
La description d’un système numérique par le biais du langage VHDL passe par 3
étapes différentes :
la déclaration des ressources externes (bibliothèques) ;
la description de l’entité du système, correspondant à la liste des
entrées/sorties ;
la description de l’architecture du système, correspondant à la définition des
fonctionnalités du système.
L’ensemble est contenu dans un fichier source portant l’extension *.vhd.
2.1 Les principales caractéristiques du langage VHDL
2.1.1 Un langage couvrant plusieurs niveau de description
Le langage VHDL couvre tous les niveaux partant des portes logiques de base
jusqu'aux systèmes complets (plusieurs cartes, chacune comprenant plusieurs
circuits). Il s'applique tout aussi bien au niveau structurel qu'au niveau
comportemental, en passant par le niveau transferts de registres ou RTL (Register
Transfer Logic).
La description comportementale
Le circuit est décrit sans tenir compte de la réalisation concrète sur un composant
donné (par exemple, on ne définit pas de signaux d’horloge). On utilise les fonctions
de haut niveau d’abstraction de VHDL. Le code est donc portable, mais il dépend
entièrement du synthétiseur pour le résultat (si un tel synthétiseur existe). Ce style de
description permet en particulier de spécifier le circuit sous forme d’un algorithme.
Technologie des circuits intégrés FPGA Bsiss Mohammed
7
La description flot de données
Le circuit est décrit grâce à plusieurs couche de registres (bascules D) reliées par de
la logique combinatoire. On utilise généralement une liste d'instructions concurrentes
d'affectations de signaux du type "<signal> <= <expression> " où <expression> peut
représenter un simple signal, ou une expression utilisant des opérateurs logiques,
arithmétiques ou relationnels, ou une expression conditionnelle. C’est la manière
traditionnelle d’écrire du VHDL et qui donne généralement les meilleurs résultats
avec les synthétiseurs commercialisés. Ce niveau de description est souvent appelé
"logiques à transfert de registres" ou RTL (Register Transfer Logic).
La description structurelle de bas niveau
Le circuit est décrit par sa structure, sous forme d’une liste de composants instanciés
et des interconnexions les reliant. En fait, c’est l’équivalent littéral d’un schéma
représentant l’interconnexion de portes élémentaires issues d'une bibliothèque.
La description structurelle de haut niveau
Le circuit est découpé en blocs fonctionnels de haut niveau qui sont reliés entre eux.
Il s’agit toujours d’un schéma, mais il représente des composants qui peuvent être
écrit en comportemental ou en RTL (mais aussi en structurel bas niveau). On
retrouve en général ce type de description dans le design supérieur d’une description
hiérarchique (top level design).
2.1.2 La portabilité
La portabilité constituait un des objectifs principaux pendant la phase de définition du
langage VHDL. L'utilisation largement répandue de ce langage est essentiellement
due au fait qu'il soit un standard. Un standard offre beaucoup plus de garanties
(stabilité, fiabilité, etc.) vis-à-vis des utilisateurs que ne le permettrait un langage
potentiellement précaire développé par une société privée. La portabilité signifie
dans le cadre des FPGA, qu’il est possible à tout moment de changer de technologie
cible (Altera, Xilinx, etc.) ou bien de famille au sein d’un même fabricant ; ou même
d’avoir une stratégie de conception qui consiste à réaliser un prototype sur un circuit
programmable (FPGA) avant de basculer sur des circuits spécifiques (ASIC ou
Application Specific Integrated Circuit).
Technologie des circuits intégrés FPGA Bsiss Mohammed
8
2.1.3 La lisibilité
La représentation schématique n'est pas toujours d'une grande lisibilité. Il est difficile
de saisir rapidement le fonctionnement d'une machine d'état parmi un
enchevêtrement de registres et de portes logiques. Une documentation écrite est très
souvent nécessaire à la compréhension d'un schéma. VHDL apporte par son
principe de modularité et d'interconnexion de composants une grande lisibilité à la
compréhension d'un système, sans pour autant supprimer l'utilité d'un dessin
fonctionnel.
2.1.4 La modularité
La modularité est une des caractéristiques essentielles de VHDL. Une description
partitionnée en plusieurs sous-ensembles est dite modulaire. VHDL supporte la
conception modulaire et hiérarchique, qui offre de nombreux avantages :
les descriptions sont plus simples,
les durées de simulation, de synthèse et de mise au point sont raccourcies,
la fiabilité est améliorée : chaque sous-ensemble peut être testé
exhaustivement,
les sous-ensembles sont réutilisables
2.2 Entité et Architecture
Un design quelconque (circuit intégré, carte électronique ou système complet) est
complètement défini par des signaux d’entrées et de sorties et par la fonction
réalisée en interne. L’élément essentiel de toute description en VHDL est formé par
le couple entité architecture qui décrit l’apparence externe d’un module et son
fonctionnement interne.
La structure d’un programme VHDL se compose toujours de deux parties
connectées.
L’entité (Entity)
L’architecture (Architetcure)
Technologie des circuits intégrés FPGA Bsiss Mohammed
9
L'entité définit les interfaces du module numérique avec son environnement. Elle
permet de définir les ports par où sont véhiculés les informations (signaux) et les
paramètres génériques. La syntaxe de la partie entité est la suivante :
Entité < nom d´entité > is
(generic <Déclaration des paramètres)>;
(port <Déclaration d’entrée/sortie>]
(local Déclaration)
End <nom d´entité>
Figure 2-1 Syntaxe de la déclaration d'Entité
L’entité est associée au moins à une description de son contenu et de son
implémentation par la partie architecture.
L’architecture d’un module décrit le comportement intérieur. Cette description peut
être de type structurel, flot de données, comportemental ou une combinaison des
trois.
A chaque entité peut être associée une ou plusieurs architectures, mais, ou moment
de l’exécution (simulation ou synthèse), seule une architecture est utilisée. .
L’architecture comprend aussi une partie déclarative où peuvent figurer un certain
nombre de déclarations (de signaux, de composants, etc.) internes à l’architecture. A
La syntaxe de la partie architecture est la suivante :
architecture < nom d’architecture > of < nom d’entité > is
[<declarations d’architecture >;]
begin
corps d’architecture
end <nom d’architecture >
Figure 2-2 Syntaxe de la déclaration d'architecture
A titre d’exemple, le code suivant donne une description possible d’architecture
associée à l’entité décrite précédemment pour un compteur N bits.
Technologie des circuits intégrés FPGA Bsiss Mohammed
10
architecture a1 of compteur is
signal INT_DOUT : std_logic_vector(DOUT'range) ;
begin
process(CLK, CLEAR) begin
if (CLEAR='1') then
INT_DOUT <= (others => '0');
elsif (CLK'event and CLK='1') then
if (CE='1') then
if (INT_DOUT=STOP-1) then
INT_DOUT <= (others => '0');
else
INT_DOUT <= (INT_DOUT + 1);
end if;
end if;
end if;
end process;
CEO <= INT_DOUT(0) and not INT_DOUT(1) and not INT_DOUT(2) and
INT_DOUT(3) and CE;
dout <= int_dout;
end;
Figure 2-3 Syntaxe de la déclaration d'architecture
La structure d’un composant décrit par le langage VHDL est présentée par la figure
suivante :
architetcure (arch_name) of entity_name is
end [entity_name];
port (port_list
);
entity entity_name is
end [entity_name];
begin
library ieee;
use ieee.std_logic_1164.all;
déclaration des
Entrées/sorties
déclaration de
l’architecture
coprs de l’architecture
Figure 2-4 : Structure d’un code VHDL
Technologie des circuits intégrés FPGA Bsiss Mohammed
11
La déclaration des interconnexions se fait par la déclaration du port qui décrit les
signaux d’entrées et de sorties ainsi que leur types logiques. Chaque signal est
spécifié par un identificateur, un sens et un type.
Le point-virgule sépare seulement les éléments individuels de la liste des signaux
d’entité, et donc, le dernier élément à la fin n’a pas de virgule.
port (
input_a : in std_logic;
input_b : in std_logic;
entity entity_name is
library ieee;
use ieee.std_logic_1164.all;
output : out std_logic
);
Figure 2-5 : Déclaration des entrées et sorties d'une entité
Le nom du signal se compose de caractère, le premier caractère doit être une lettre.
À noter que le langage VHDL ne fait pas une distinction entre les majuscules et les
minuscules.
port (Liste des signauxt : [in|out|inout|buffer] Le type de données [:=value]);
Figure 2-6 Syntaxe de la déclaration des ports
Les interfaces du module numérique avec son environnement se fait par des
signaux, qui peuvent prendre les sens suivants :
Un signal peut être définit comme une entrée ‘IN’
Un signal peut être définit comme une en sortie ‘OUT’
Un signal peut être définit comme une entrée et une sortie `’INOUT’
Un signal peut être définit comme une sortie rétroactive ‘BUFFER’
La déclaration du paquetage ‘STD_LOGIC_1164’ exporte le type énuméré à neuf
états ainsi que les vecteurs et sous-types dérivés, accompagnés d’une fonction de
résolution. Les opérateurs logiques sont surchargés et des fonctions de conversion
de type sont aussi exportées. La déclaration de ce paquetage est la suivante :
Package STD_LOGIC_1164 is
‘U’ uninitialized / état non initialisé
‘X’ fociing unknown / niveau non définit
‘0’ forcing 0 / niveau bas
Technologie des circuits intégrés FPGA Bsiss Mohammed
12
‘1’ forcing 1 / niveau haut
‘Z’ high impedance / état haute impédance
‘W’ weak unknown / après une initialisation, le signal prend niveau non définit
‘L’ Weak 0 (Pull-down) après une initialisation, le signal prend niveau bas
'U’ weak 1 (Pull-up) après une initialisation, le signal prend niveau haut
‘-’ don’t care / le signal prend n’importe quelle valeur
2.3 Signaux et variables
Toute donnée traitée par VHDL doit être déclaré sous-forme :
d’une constante, exemple :constante pi: real:= 3.1416
d’une variable immédiatement modifiables par une affectation (:=), exemple :
variable stop : boolean ;
ou d’un signal
À noter que les signaux sont comparables à un fil électrique où sont véhiculées les
informations.
Les signaux peuvent être déclarés au sein d’un code VHDL que dans certaines
parties du code:
À l´intérieur d’entité.
- À l´intérieur d'une architecture.
Signal (name-list : Le type de données [:=start value])
Figure 2-7 : Syntaxe des signaux
2.4 Type de données
Les types des signaux peuvent être les suivants :
Types prédéfinis : integer, natural (entier >= 0), positive (entier > 0), bit, bit_vector,
boolean, real, time, std_logic, std_logic_vector.
Exemples :
Var_Data : in integer range -128 to 127 ; (Var_Data est compris entre –128 et +127)
DATA1 : in bit_vector(15 downto 0) ; (DATA1 est un bus 16 bits)
Technologie des circuits intégrés FPGA Bsiss Mohammed
13
DATA2 : out std_logic_vector(7 downto 0) ; (DATA2 est un bus 8 bits)
Types définis par l’utilisateur :
Les types énumérés.
Exemple :
type ETAT is (UN, DEUX, TROIS) ;
TOTO : out ETAT ;
Les tableaux.
Exemple :
Type TABLEAU8x8 is array (0 to 7) of std_logic_vector(7 downto 0) ;
TAB8x8 : out TABLEAU8x8;
Les sous-types.
Exemple :
subtype OCTET is bit_vector(7 downto 0) ;
BUS : inout OCTET ;
Le langage VHDL offre aussi des types de données prédéfinis, d'une part, tels que
‘integer’, ‘real’, ‘enumerated’, ‘physical’, ‘bit’, etc., qu’on peut les trouvés par défaut
dans des bibliothèques, d´autre il offre aussi la possibilité à des types de données
personnalisés
TYPE var1 is range 0 to 30;
variable temp_3 : var1;
Figure 2-8 Types de données défini par l’utilisateur
TYPE HuitBits is range 0 to 255;
TYPE state is (init, ST1, ST2, exit);
TYPE word is array (0 to 31) of bit;
Figure 2-9 Types de données défini par l’utilisateur
La déclaration de type ne peut être située que dans la section :
entité
architecture
Paquetage Body
Bloc
Processus
Technologie des circuits intégrés FPGA Bsiss Mohammed
14
Fonction
Procédure
2.4.1 Types simples
Les types de données prédéfinis dites simples ont un certain nombre de types qui
appartiennent aux classes suivant :
1. Scalaire (integer, real, enumerated, physical)
2. Composé (array, record)
3. Pointeur (access)
4. Fichiers (file)
2.4.2 Types énumérés
Les types énumérés sont de type de données scalaire, dans lequel les identificateurs
peuvent seulement accepter une certaine valeur.
TYPE état is (s1,s2,s3); Identificateurs
Figure 2-10 : Syntaxe des types énumérés
2.4.3 Les types intégraux
Les types intégraux sont les types de classe scalaires.
TYPE int(real)_identifier IS RANGE range_low TO range_high;
TYPE int(real)_identifier IS RANGE range_low DOWNTO range_high;
TYPE int(real)_identifier IS RANGE other_int(real)_identifier’RANGE;
Figure 2-11 Syntaxe des types entiers
2.4.4 Les types physiques
Un type physique représente une unité physique, comme par exemple. (Longueur,
temps, etc.).Pour la déclaration de ce type la spécification d'une unité de base est
nécessaire.
Technologie des circuits intégrés FPGA Bsiss Mohammed
15
TYPE type_name IS RANGE range_low TO range_high;
UNITS base_units;
{unités dérivées}
END UNITS;
Figure 2-12 Syntaxe des types physiques
2.4.5 Types tableaux
Les types tableaux sont parmi les types de données, dont les objets peuvent
accepter plusieurs valeurs. Si les objets sont composés de plusieurs types, alors le
type de données "record" est utilisé. On peut avoir une déclaration de type tableau à
une dimension
TYPE Identificateurs IS Array
(index_type RANGE <>) OF typ_definition
Figure 2-13 Déclaration des tableaux à une dimension
Ou bien multidimensionnel.
TYPE Identificateurs IS Array
(typ_definition RANGE <>)
({,typ_definition }) OF typ_definition
Figure 2-14 Déclaration des tableaux multidimensionnels
2.5 Les opérateurs logiques
Les opérateurs booléens sont prioritaires tels que "not", "and", "nand" "or", et "xor"
etc. Les opérateurs d’une priorité plus haute seront exécutés les premier.
Technologie des circuits intégrés FPGA Bsiss Mohammed
16
notabs**
remmod
*
&-+
</== >=><=
nandorand xornor
priorité haute
priorité basse
** := l’operateur exponent
Mod := modulo
Rem := Le reste du division
Abs := La valeur absolue
Figure 2-15 : Les niveaux prioritaires des opérateurs
2.5.1 Attribute
Avec les attributs, on peut recueillir des informations importantes sur les types et les
objets. Ces informations peuvent être utiles pour le paramétrage du modèle généré.
Le langage VHDL fournit un ensemble d'attributs prédéfinis.
name’Attribut_ Identificateurs
Figure 2-16 : Syntaxe de la déclaration des attributs
L'indicateur "name" représente le nom d'un type, sous-type ou un objet, et "Attribut_
indicateur» indique le nom de l'attribut.
2.6 Fonctionnement séquentiel
Les instructions concurrentes pourraient suffire à définir un langage de description
matériel. Cependant, certains circuits sont plus faciles à décrire en utilisant des
instructions séquentielles similaires à des instructions de langages classiques de
programmation. En VHDL, les instructions séquentielles ne s’utilisent qu’à l’intérieur
des processus. Un processus est un groupe délimité d’instructions, doté de trois
caractéristiques essentielles :
Le processus s’exécute à chaque changement d’état d’un des signaux
auxquels il est déclaré sensible.
Technologie des circuits intégrés FPGA Bsiss Mohammed
17
Les instructions du processus s’exécutent séquentiellement.
Les modifications apportées aux valeurs de signaux par les instructions
prennent effet à la fin du processus.
L’exemple de la description suivante montre une architecture (seule) d’un latch D
contenant un processus qui est exécuté lors du changement d’état de l’horloge CLK.
architecture comportement of com_D is
begin
Process (CLK)
Begin
If CLK= ‘1’ then Q <= D;
End if;
End process;
2.7 Processus concurrent
Le comportement d'un circuit peut être décrit par un ensemble d'actions s'exécutant
en parallèle. C'est pourquoi VHDL offre un jeu d'instructions dites concurrentes. Une
instruction concurrente est une instruction dont l'exécution est indépendante de son
ordre d'apparition dans le code VHDL. Par exemple, prenons le cas d'un simple
composant COMP_2, comme la montre la figure :
Les deux portes constituant ce verrou fonctionnent en parallèle. Une description
possible de ce circuit est donnée dans le code suivant (seule l'architecture est
donnée).
architecture comportement of COMP_2 is
begin
F <= not ( ( A and B ) or ( C and D ) )
end comportement;
Technologie des circuits intégrés FPGA Bsiss Mohammed
18
2.8 Instructions composites
Instruction IF :
Cette instruction est triviale : Si la condition après IF n’est pas remplie, la condition
après ELSIF sera effectuée. Si cela ne s’applique pas, alors la déclaration suivante
ELSE est exécutée sans autre vérification. On peut utiliser un nombre illimité des
déclarations ELSIF, mais une seule déclaration d’ELSE à la fin de l’instruction.
entity alg_nand is
port(
a,b : in std_logic;
c : out std_logic);
end alg_nand;
Architecture rtl of alg_nand is
Begin
Process (a,b)
Begin
If a= ‘1’ anf b= ‘1’ then c <= ‘0’;
Elsif a= ‘0’ anf b= ‘0’ then c <= ‘1’;
ELSE
c<= ‘X’;
End if;
End process ;
End rtl;
Instruction case :
Cette instruction compare le sélecteur qui doit être d’un type discret ou vecteur de
discrets avec les valeurs, qui doivent être des constantes de même type. La
séquence d’instructions qui correspond est exécutée.
[Label] : case selecteur is
When valeur1 => sequence d’instructions;
When valeur2 to valeur3=> sequence d’instructions ;
When valeur4|valeur5 => sequence d’instructions;
When others => sequence d’instructions;
End case;
Technologie des circuits intégrés FPGA Bsiss Mohammed
19
2.9 Loop
La boucle contient du code qui va être exécuté répétitivement un nombre de fois qui
dépend de sa condition d’arrêt. Elle existe trois formes :
La boucle infinie :
La boucle infinie, comme son nom l’indique, ne s’arrête jamais (sauf exécution de
l’instruction exit).
La boucle for:
La boucle est contrôlée par un indice qui lui-même varie selon un schéma donné en
tête : il parcourt une étendue ( RANGE) qui est donnée explicitement : 2 to 9 ; ou par
référence à un type ou un objet : A’RANGE.
[Label:] for I in 1 to 10 loop …end loop;
[Label:] for I in 10 downto 1 loop …end loop;
[Label:] for I in A’RANGE loop …end loop;
La boucle while:
La boucle est contrôlée par l’évaluation d’une condition. Tant que la condition est
vraie, la séquence d’instructions est exécutée. Si la condition est fausse avant
d’entrer dans la boucle, la séquence n’est pas exécutée du tout.
[Label:] while condition loop…end loop;
2.1 Instructions contextuelles
Certaines instructions n’ont pas de sens que dans certaines contextes: dans une
boucle, ou dans un sous-programme. On pourrait y ranger les instructions wait et
break qui ne peuvent pas exister dans une fonction (une fonction s’exécute à temps
de simulation strictement nu, même pas un delta) et donc non plus dans un
procédural puisque sa définition fait appel à une fonction équivalence.
La boucle exit:
exit : fait sortir la boucle la plus interne
exit label. Fait sortir la boucle dont le nom est label.
L’instruction peut être conditionnelle :
exit when condition
Technologie des circuits intégrés FPGA Bsiss Mohammed
20
exit label when condition
Next:
next : fait recommencer à son début la boucle la plus interne.
next label : fait recommencer à son début la boucle dont le nom est label.
L’instruction peut être conditionnelle :
next when condition
next label when condition
Retrun:
Return valeur ; Permet de sortir d’une fonction et de rendre la valeur. C’est la seul
façon légale de sortir d’une fonction. Autrement dit, si une fonction arrive sur son end
, c’est une errer à l’exécution.
Return ; (sans valeur) Permet de sortir d’une procédure On peut aussi en sortir en
passant par le end.
2.1 La synthèse
La synthèse est définie comme une succession d'opérations permettant à partir d'une
description de circuit dans un domaine fonctionnel (description comportementale)
d'obtenir une description équivalente dans le domaine physique (description
structurelle).
Le processus de synthèse peut être défini comme une boîte noire ayant en entrée
une description abstraite en termes de langages de description matérielle, et comme
sortie une description structurée en termes de dispositifs interconnectés (une netlist).
2.1.1 Le but de la synthèse
Le premier intérêt de la synthèse est de permettre une description la plus abstraite
possible d'un circuit physique. Le concepteur a de moins en moins de détails à
donner. Par exemple, pour décrire un compteur, la description détaillée des signaux
de contrôle explicitement utilisés n'est pas indispensable. Seule la fonctionnalité de
comptage et les contraintes de synthèse (qui peuvent être des contraintes de temps,
d’optimisation, de circuit cible, etc.) doivent être indiquées. Le but de l'abstraction est
de réduire et de condenser les descriptions au départ et, par conséquent, de faciliter
Technologie des circuits intégrés FPGA Bsiss Mohammed
21
leur correction en cas d'erreurs. L'autre avantage de l'abstraction est la portabilité.
Plus l'abstraction est élevée, plus la description est portable. En effet, une
abstraction élevée ne fait pas référence à un composant cible car elle ne spécifie pas
les détails. Puisque les systèmes deviennent de plus en plus complexes, il ne sera
bientôt plus possible d'envisager leur conception en saisie de schéma. Avec la
synthèse, le nombre d'informations devant être fournies par le concepteur diminue.
Ces informations consistent essentiellement en la description comportementale du
circuit et des contraintes correspondantes. La synthèse amènera sans aucun doute
dans les prochaines années, à des circuits plus sûrs, plus robustes et devrait, à
l’avenir, être considérée comme une marque de qualité dans le cycle de conception.
Puisque la synthèse permet de réduire la taille des descriptions, elle permet
également de faciliter les remises à jour, de rendre les corrections plus rapides, et de
pouvoir explorer un ensemble plus vaste de solutions architecturales. Dans ce
contexte, le meilleur compromis entre coût et performance peut plus facilement être
atteint par le concepteur. Le grand nombre de descriptions déjà existantes couplé
avec la possibilité de les paramétrer amènent à la création de ressources de
bibliothèques réutilisables. Ceci permet d'améliorer encore plus la productivité des
circuits électroniques.
Technologie des circuits intégrés FPGA Bsiss Mohammed
22
2.1.2 Exemples commentés de circuits logiques portes
combinatoires
La ligne 1 définit l’appel à la librairie IEEE grâce à l’instruction « library
nom_de_la_librairie ». La ligne 2 indique l’utilisation de tous les éléments
(fonctions ou composants ou type comme std_logic) du paquetage (ou
package) std_logic_1164 grâce à l’instruction « use
nom_de_la_librairie.nom_du_package.all ».
Lignes 3 à 6 : définition des entrées-sorties du design GATE. Le mot clé port
annonce la liste des signaux d’interface. 4 modes sont possibles pour ces
entrées-sorties: in, out, inout, buffer.
Technologie des circuits intégrés FPGA Bsiss Mohammed
23
Lignes 7 à 16 : La partie déclarative de l’architecture (entre les mots clés
architecture et begin) est destinée à la déclaration des objets internes (les E/S
sont déclarées dans l’entity) utilisés dans cette architecture. Ces objets sont
généralement des signaux, constantes, variables ou alias.
Compte tenu de ce qui précède, on voit que le circuit GATE réalise les fonctions
logiques suivantes :
Technologie des circuits intégrés FPGA Bsiss Mohammed
24
2.1.3 Exemples commentés de circuits logiques multiplexeurs
Technologie des circuits intégrés FPGA Bsiss Mohammed
25
Lignes 8 à 33. Les opérateurs relationnels suivants sont présents dans les
instructions conditionnelles de VHDL telles que « when … else », « if … then
… else » ou « case » : =, /=, <, <=, >, >=. Ils retournent un résultat booléen
(vrai/faux). Exemple : if (a > b) then …
Faites attention à ne pas confondre l’assignation X <= Y ; avec l’opérateur relationnel
inférieur ou égal. Les opérateurs relationnels peuvent être combinés aux opérateurs
logiques de la manière suivante : if (a <= b and b=c) then…
L’opérateur de concaténation permet d’associer deux objets de type std_logic ou
std_logic_vector. Exemples :
signal octet1, octet2 : std_logic_vector(7 downto 0) ;
signal mot1, mot2 : std_logic_vector(15 downto 0) ;
mot1 <= octet1&octet2 ;
mot2 <= "100"&octet1(3 downto 0)&octet2&’1’ ;
Il permet de simplifier l’écriture de :
if (A = ‘1’ and B = ’0’) then …
en écrivant :
if (A&B) = "10" then …
La ligne 11 décrit un multiplexeur 2 entrées avec l’assignation conditionnelle
when. En effet, la phrase « Y1 prend la valeur de A si Sel(0) est égal à 0 sinon
(Y1 prend la valeur de) B » décrit bien un multiplexeur deux entrées A et B
vers une sortie Y1 avec une entrée de sélection reliée au bit de poids faible de
Sel. La condition testée doit être booléenne ce qui est bien le cas puisque les
opérateurs relationnels fournissent un résultat booléen.
Lignes 12 à 32 : fonctionnement concurrent et séquentiel. En électronique, les
composants fonctionnent simultanément (fonctionnement parallèle ou
concurrent) alors qu’en programmation traditionnelle, les instructions
s’exécutent les unes à la suite des autres de façon séquentielle. Les deux
modes de fonctionnement coexistent dans VHDL suivant que le code se
trouve hors d’un processus (fonctionnement concurrent) ou dans un
processus (fonctionnement séquentiel). Prenons par exemple la séquence
suivante :
A <= B ;
B <= C ;
Technologie des circuits intégrés FPGA Bsiss Mohammed
26
En programmation traditionnelle, la séquence signifierait « A prend la valeur de B,
puis B prend la valeur de C ». A la fin du programme, A et B on des valeurs
différentes. Si on change l’ordre des instructions, la signification change. C’est le
fonctionnement séquentiel.
En VHDL, il faut comprendre : à tout moment, A prend la valeur de B et à tout
moment, B prend la valeur de C. En clair A, B et C ont tout le temps la même valeur
quel que soit l’ordre des instructions. C’est le fonctionnement concurrent.
Voyons maintenant ce qu’est un processus. C’est un groupe délimité d’instructions
doté de trois caractéristiques :
1. Le processus s’exécute à chaque changement d’état d’un des signaux
auxquels il est déclaré sensible.
2. Les instructions dans le processus s’exécutent séquentiellement.
3. Les modifications apportées aux valeurs de signaux par les instructions
prennent effet à la fin du processus.
La structure d’un processus est la suivante :
Nom_de_processus : process (liste_de_sensibilité)
-- déclaration des variables locales du processus
begin
-- corps du processus
end process Nom_de_processus ;
Ligne 12 : le processus p0 se déclenche sur chaque changement d’état des
signaux A, B et Sel. Ligne 13 à 18 : on décrit à nouveau un multiplexeur 2
entrées avec l’assignation conditionnelle « if … then … else … ». En effet, la
phrase « si Sel(0) est égal à 0, Y2 prend la valeur de A sinon Y2 prend la
valeur de B » décrit bien un multiplexeur deux entrées A et B vers une sortie
Y2 avec une entrée de sélection reliée au bit de poids faible de Sel.
Ligne 23 : le processus p1 se déclenche sur chaque changement d’état des
signaux A, B, C, D et Sel. Lignes 25 à 31 : on décrit un multiplexeur 4 entrées
avec l’assignation sélective case.
Ligne 25 : le sélecteur est le bus Sel, de largeur 2 bits.
Ligne 26 : Quand Sel vaut 00, Y4 prend la valeur de A,
Technologie des circuits intégrés FPGA Bsiss Mohammed
27
Ligne 27 : Quand Sel vaut 01, Y4 prend la valeur de B,
Ligne 28 : Quand Sel vaut 10, Y4 prend la valeur de C,
Ligne 29 : Quand Sel vaut 11, Y4 prend la valeur de D,
Ligne 30 : pour toutes les autres valeurs de Sel (n’oubliez pas que Sel est un
std_logic_vector dont chaque bit peut prendre 9 états), Y4 prend la valeur de A. C’est
la valeur par défaut qui est fortement recommandée. On verra un peu plus loin que
cela permet d’éviter d’inférer (de générer) un latch. On a bien décrit un multiplexeur 4
entrées A, B, C, D une sortie Y4 et deux bits de sélection Sel.
Nous allons maintenant lister les instructions séquentielles qui doivent se trouver
obligatoirement à l’intérieur d’un processus et les instructions concurrentes qui
doivent obligatoirement se trouver à l’extérieur d’un processus.
Instructions en mode concurrent.
Assignation inconditionnelle. Forme générale : signal <= expression ;.
A <= B and C ; -- A prend la valeur du résultat de l’opération (B and C).
X <= ‘0’ ; -- X prend la valeur 0.
Assignation conditionnelle. Forme générale : signal <= expression when condition
else expression ;.
Y1 <= A when Sel(0) = '0' else B; -- Y1 prend la valeur de A si Sel(0) est égal à 0
sinon (Y1 prend la valeur de) B.
Assignation sélective. Forme générale : with selecteur select signal <= {expression
when valeur_selecteur,} ;.
With ETAT select
X <= A when "00", -- X prend la valeur de A si le signal ETAT, utilisé comme
B when "01", -- sélecteur, vaut 00, B si ETAT vaut 01, etc.
C when "10",
D when others ;
Instanciation de composant. Forme générale : nom_d’instance :
nom_du_composant port map (liste_des_signaux_d’entréee et de sortie du
composant) ;.
Technologie des circuits intégrés FPGA Bsiss Mohammed
28
U0 : XOR4 port map (A, B, C, D, S) ; -- on insère le composant XOR4 dans le
design (à la manière d’un symbole dans un schéma). U0 est le nom d’instance.
A, B, C, D sont les entrée de U0, S est sa sortie.
Instruction generate. Cette instruction permet de générer plusieurs répliques d’un
composant ou d’une équation. Exemple, le composant ADDER dans le package de
tp4.
gen : for j in 7 downto 0 generate -- pour j allant de 7 à 0
genlsb : if j = 0 generate -- génération de l’additionneur complet du bit de poids
faible
fa0 : FullAdder port map (A => A(0), B => B(0), CI => CI, S => S(0), COUT =>
C(1));
end generate;
genmid : if (j > 0) and (j < 7) generate -- génération des autres additionneur
fa0 : FullAdder port map (A => A(j), B => B(j), CI => C(j), S => S(j), COUT =>
C(j+1));
end generate;
genmsb : if j = 7 generate -- génération de l’additionneur complet du bit de
poids fort
fa0 : FullAdder port map (A => A(j), B => B(j), CI => C(j), S => S(j), COUT =>
COUT);
end generate;
end generate;
Instructions en mode séquentiel.
Assignation inconditionnelle de signal. Forme générale : signal <= expression
;.
A <= B and C ; -- A va prendre la valeur du résultat de l’opération (B and C) à la
fin
du processus.
X <= ‘0’ ; -- X prend la valeur 0 à la fin du processus.
Assignation inconditionnelle de variable. Forme générale : var := expression ;.
X := ‘0’ ; -- X prend la valeur 0 immédiatement.
Assignation conditionnelle de signal ou de variable.
if (Sel(0) = '0') then -- si Sel(0) est égal à 0, Y2 prend la valeur de A
Technologie des circuits intégrés FPGA Bsiss Mohammed
29
Y2 <= A;
else -- sinon Y2 prend la valeur de B
Y2 <= B;
end if;
Assignation sélective.
case Sel is
when "00" => Y4 <= A; -- si Sel vaut 00, Y4 prend la valeur de A
when "01" => Y4 <= B; -- si Sel vaut 01, Y4 prend la valeur de B
when "10" => Y4 <= C; -- si Sel vaut 10, Y4 prend la valeur de C
when "11" => Y4 <= D; -- si Sel vaut 11, Y4 prend la valeur de D
when others => Y4 <= A; -- pour toute autre valeur de Sel, Y4 prend la valeur
de A
end case;
Boucles.
for i in 0 to 7 loop -- pour i allant de 0 à 7
datari(i) <= "000"&datar(i); -- datari(i) prend la valeur "000" concaténée avec datar(i)
end loop;
Lignes 19 à 21 : mémorisation implicite. En VHDL, les signaux ont une valeur
courante et une valeur prochaine déterminée par l’opérateur d’assignation. Si
lors d’une instruction conditionnelle (concurrente ou séquentielle) un signal
reçoit une assignation dans une branche alors il doit recevoir une assignation
dans toutes les autres branches. Si tel n’est pas le cas, chaque absence
d’assignation signifie que la prochaine valeur est identique à la valeur
courante et le synthétiseur doit générer une logique de mémorisation (bascule
D ou latch). Dans notre exemple, si Sel(1) vaut 1, Y3 prend la valeur de A et
sinon, Y3 garde sa valeur courante. Le synthétiseur infère donc un latch au
lieu d’un multiplexeur.
Le circuit MUX réalise donc les fonctions logiques suivantes :
Technologie des circuits intégrés FPGA Bsiss Mohammed
30
Technologie des circuits intégrés FPGA Bsiss Mohammed
31
3 Les logiques programmables (FPGA/PLD)
Dans ce chapitre, les principaux éléments d’une puce FPGA seront présentés.
3.1 Introduction
Dans les années 70, le nombre de transistors intégrés sur une puce de silicium
augmentait régulièrement. Les fabricants mettaient sur le marché des composants
LSI (Large Scale Integration) de plus en plus spécialisés. Par exemple, le circuit
74LS275 contenait 3 multiplieurs de type Wallace. Ce genre de circuit n'était pas
utilisable dans la majorité des applications. Cette spécialisation des boîtiers
segmentait donc le marché des circuits intégrés et il devenait difficile de fabriquer
des grandes séries. De plus, les coûts de fabrication et de conception augmentaient
avec le nombre de transistors. Pour toutes ces raisons, les catalogues de
composants logiques standards (série 74xx) se sont limitées au niveau LSI. Pour tirer
avantage des nouvelles structures VLSI (Very Large Scale Integration), les fabricants
développèrent 4 nouvelles familles :
Les microprocesseurs et les mémoires RAM et ROM : les microprocesseurs et
les circuits mémoires sont attrayants pour les fabricants. Composants de base
pour les systèmes informatiques, ils sont produits en très grandes séries.
Les ASSP (Application Specific Standard Product) : ce sont des produits sur
catalogue qui sont fabriqués en grande série. La fonction réalisée est figée par
le constructeur, mais le domaine d’utilisation est spécifique à une application.
Exemple : un contrôleur Ethernet, un encodeur MPEG-4, …
Les circuits programmables sur site : n'importe quelle fonction logique,
combinatoire ou séquentielle, avec un nombre fixe d'entrées et de sorties,
peut être implantée dans ces circuits. A partir de cette simple idée, plusieurs
variantes d'architecture ont été développées (PAL, EPLD, FPGA,…).
Technologie des circuits intégrés FPGA Bsiss Mohammed
32
Les ASIC (Application Specific Integrated Circuit) réalisés chez le fondeur : le
circuit est conçu par l'utilisateur avec des outils de CAO, puis il est réalisé par
le fondeur.
A l'heure actuelle, la majorité des circuits numériques est issue de ces 4 familles.
Cependant, certains éléments simples du catalogue standard (famille 74) sont
toujours utilisés.
Plus simplement, on peut distinguer deux catégories de circuits intégrés : les circuits
standards et les circuits spécifiques à une application :
Les circuits standards se justifient pour de grandes quantités :
microprocesseurs, contrôleurs, mémoires, ASSP, …
Les circuits spécifiques sont destinés à réaliser une fonction ou un ensemble
de fonctions dans un domaine d’application particulier.
La figure suivante représente une classification des circuits intégrés numériques.
Dans la littérature, le terme ASIC est employé pour décrire l’ensemble des circuits
spécifiques à une application. Or, dans le langage courant, le terme ASIC est
Technologie des circuits intégrés FPGA Bsiss Mohammed
33
presque toujours utilisé pour décrire les circuits réalisés chez un fondeur. On
désigne, par le terme générique PLD (Programmable logic Device), l’ensemble des
circuits programmables par l’utilisateur.
Parmi les circuits numériques spécifiques à une application, il faut distinguer deux
familles :
les circuits conçus à partir d’une puce de silicium « vierge » (Full-custom),
les circuits où des cellules standards sont déjà implantées sur la puce de
silicium (Semi-custom).
Dans le premier groupe, les circuits appelés « Full custom », on trouve les circuits à
la demande et ceux à base de cellules (CBIC : Cell Based Integrated Circuit). Le
fondeur réalise l'ensemble des masques de fabrication. Dans le second groupe, les
circuits appelés « Semi-custom », on trouve les circuits prédiffusés (GA : Gate Array)
et les circuits programmables.
Les cellules standards, déjà implantées sur la puce de silicium, doivent être
interconnectées les unes avec les autres. Cette phase de routage est réalisée, soit
par masquage chez le fondeur (prédiffusé), soit par programmation. Avant d’aborder
le détail de la classification des circuits numériques spécifiques à une application, un
aperçu est donné sur les méthodes de réalisation des interconnexions pour les
circuits "Semi-custom".
3.2 Technologie utilisée pour les interconnexions
Les cellules standards implantées dans les circuits "Semi-custom" vont de la simple
porte jusqu'à une structure complexe utilisant un grand nombre de transistors. Il
existe plusieurs méthodes servant à interconnecter ces cellules :
par masque (fondeur),
par fusible,
par anti-fusible,
par cellule mémoire : EPROM, EEPROM, flash EPROM et SRAM.
Dans la méthode dite « interconnexion par masque », le fondeur réalise les
interconnexions par métallisation en créant les derniers masques de fabrication (2
masques par couches de métallisation). Cette méthode n'est utilisée que pour les
circuits prédiffusés.
Technologie des circuits intégrés FPGA Bsiss Mohammed
34
Les autres méthodes sont utilisées dans les PLD. Dans ces circuits, les fils de liaison
existent déjà (organisée en lignes et en colonnes), mais ils ne sont reliés ni entre
eux, ni avec les éléments logiques du circuit. Il faut donc arriver à créer une
interconnexion entre deux fils.
Deux possibilités existent : les interconnexions directes ou les interconnexions par
cellule mémoire.
3.2.1 Interconnexion directe
Interconnexion par fusible
C'est la technique des PROM bipolaires à fusibles (Programmable Read Only
Memory). On insère, entre chaque intersection, une diode en série avec un fusible.
Pour supprimer la connexion entre deux lignes, il suffit d'appliquer une tension
élevée pour claquer le fusible. Le boîtier n'est donc programmable qu'une seule fois
par l'utilisateur. Cette méthode n’est plus utilisée aujourd’hui.
Interconnexion par anti-fusible
Avec cette technique, c'est l'opération inverse qui est réalisée. On ne coupe pas une
liaison, mais on l'établit. L'anti-fusible isole deux lignes métalliques placées sur deux
niveaux différents grâce à une fine couche d'oxyde de silicium. Si on applique une
impulsion élevée ( ≈ 21V) calibrée en temps (moins de 5 ms), la couche d'oxyde est
trouée et les deux lignes se retrouvent en contact. La résistance entre les deux
lignes passe alors de 100 M Ω à 100 Ω . Comme pour la technique du fusible, le
Technologie des circuits intégrés FPGA Bsiss Mohammed
35
boîtier n'est programmable qu'une seule fois par l'utilisateur. Cette méthode est peu
utilisée (à part par ACTEL).
3.2.2 Interconnexion par cellule mémoire
Field programmable gate arrays (FPGA) sont des éléments logiques programmables.
Á l´intérieur de l´élément le module il y a plusieurs petites unités de «blocs logiques»,
également dénommée CLB (configurable logic blocks), qui à leur tour, sont reliés
pour un réseau de connexions entre eux. Ainsi, un routage universel est possible.
Les FPGAs ont aussi des blocs SRAM, appelés blocs de RAM, pour stocker les
données. Certains FPGAs contiennent on aussi des PLLs (Phase Locked Loop), des
DLLs (Delay Locked Loop), des traitements d´impulsions (DCM: Digital Clock
Manager) et aussi des simple ALUs (Arithmetic Logic Unit). Dans la conception
FPGA peuvent être mise en œuvre des logiques plus complexes. Au lieu de ou bien
tant que CoμP ils sont approprié pour DSP et, par conséquent, à 100 fois plus vite
que les DSP. La raison réside dans les numéros d'immatriculation élevée et le
parallélisme dans le FPGA. Ils peuvent être utilisés comme des processeurs RISC ou
un coprocesseur. Il existe même l'utilisation du FPGA comme Power PC. La société
"Xilinx" a été fondée en 1984 et son siège est à San Jose. Les principaux domaines
Technologie des circuits intégrés FPGA Bsiss Mohammed
36
de la société «Xilinx» sont le développement des circuits intégrés logiques
programmables (FPGA, EPROM), les outils de conception de logiciels, fonctions
prédéfinis de système, et des cores. Le future but de Xiling est le lancement d´un
processeur Power PC intégré FPGA avec les standards 1/0 les plus rapides et des
bibliothèques d´interface sur le marché. Pour l´essentiel en distingue entre deux
types de FPGA. Premièrement, le FPGA reconfigurable, et deuxiement les FPGA
non reconfingurable.cependant la seconde Technologie de stockage est utilisée chez
deux fabricants seulement: "Actel" et " Quiklogic. Toutes les autres sociétés utilisent
la technologie de mémoire reconfigurable comme en peut considérer dans le tableau
suivant.
Tableau 3-1 Technologie de stockage
Technologie Fabricant Ensemble
fonctionnel
Architecture
Antifuse Actel
Quicklogic
ACTx FPGA
FPGA
SRAM Altera
Altera
Atmel
Cypress
Lucent
Xilinx
APEX
FLEX
AT40K
Delta39K
ORCA
Virtex
CPLD/FPGA
FPGA/CPLD
FPGA
CPLD
FPGA
FPGA
EEPROM Altera
Lattice
Xilinx
MAX
Godfather
Coolrunner
CPLD
CPLD
CPLD
Les FPGA reconfigurable utilisent SRAM et EEPROM et permettent ainsi une
description rapide et fréquente. L'inconvénient de la technologie de mémoire
reconfigurable est la grande empreinte de mémoire SRAM et EEPROM, qui sont
nécessaires sur la puce. Après chaque redémarrage FPGAs reconfigurables doivent
être réécrites. Cela peut être évité, en utilisant p.ex. EEPROM, parce que les FPGA
sont en mesure de lire les données à partir d'un EEPROM en série ou d'un
microprocesseur pour se configurer ainsi sois-même (série master mode).
Les -FPGAs non reconfigurable utilisent la mémoire antifusible. Ceux-ci exigent très
peu d'espace sur la puce et ils ont une résistance très faible et une faible capacité.
La programmation de ce type de FPGA prend du temps et ne peut être effectuée
qu'une fois. Le programme existe toujourslors d´un redémamage.
Technologie des circuits intégrés FPGA Bsiss Mohammed
37
Le chapitre suivant décrit l'architecture FPGA, illustré par les «XC2V500-XC2V1000"
fabriqué par Xilinx. Au préalable, la différence entre FPGA et PLD classique sera
expliquée.
3.3 Architecture de Xilinx FPGA Spartan-3
Ce paragraphe détaille la structure interne des FPGA de la famille Spartan-3
fabriqués par la société XILINX.
3.3.1 Caractéristiques générales
La figure suivante présente l'architecture de la famille Spartan-3. On reconnaît là,
une structure de type prédiffusé.
GCM
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
..
..
CLB
CLB
CLB
CLB
Blo
ck S
ele
ctR
AM
Blo
ck S
ele
ctR
AM
Mu
lzip
lier
Mu
lzip
lier
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
Blo
ck S
ele
ctR
AM
Blo
ck S
ele
ctR
AM
Mu
lzip
lier
Mu
lzip
lier
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
IOB IOB DCM IOB IOB IOB IOB DCM IOB IOB
IOB
WWWW
IOB
IOB
IOB
IOB
IOB
IOB
..
..
..
....
..
Configurable logic
Programmable I/Os
Image 3-1 Architecture Virtex-II
La famille Spartan-3 est une famille de FPGA CMOS SRAM faible coût basée sur la
famille Virtex-II (FPGA complexité élevée). La liste suivante résume ses
caractéristiques :
matrice de blocs logiques programmables ou CLB (Configurable Logic Block),
Technologie des circuits intégrés FPGA Bsiss Mohammed
38
blocs d'entrée/sortie programmables ou IOB (Input Ouput Block) dont le
nombre varie suivant le type de boîtier (QFP ou BGA). Ils supportent 23
standards d’E-S plus le contrôle des impédances d’entrée et de sortie via DCI,
réseau de distribution d'horloge avec une faible dispersion via les DCM,
des blocs RAM 18 kbits,
des multiplieurs 18 bits x 18 bits,
de nombreuses ressources de routage.
Cette famille comprend 8 membres allant d’une capacité de 1728 à 74880 cellules
logiques (une LUT associée à une bascule D) :
d´une d´ensemble. En plus des éléments mentionnés précédemment sont ici
également les bloc-RAMs. Les BRAMs sont des blocs SRAM intégrés et fournissent
et de fournir une ressource supplémentaire pour un stockage rapide.
En outre, l'architecture Virtex fournit pour chaque tampon global d'horloge d'entrée
un soi-disant horloge numérique sur la gestion (DCM). Cela sert à éliminer les
décalage de signaux résultant des différences du temps entre l'atténuateur d'entrée
d'horloge et la puce interne de pins d'horloge d'entrée.C´est pourquoi les DCMS
veillent à ce qui est livré dans la puce de l'ensemble, une impulsion d'horloge
synchrone.
Les boîtiers suivants sont disponibles :
Technologie des circuits intégrés FPGA Bsiss Mohammed
39
3.3.2 Réalisation de la logique combinatoire
Les blocs logiques PLD consistent essentiellement de grilles and/or. Cela permet que
chaque fonction circuit puisse être réalisée dans une opération and/or. Le plus la
fonction est complexe, le plus on doit utiliser de termes de ces produits. Au contraire
des blocs logiques les FPGAs utilisent des tableaux Lookup, qui se composent de
quatre entrées.. A cela les fonctions qui nécessitent plus de quatre signaux sont
distribuées sur plusieurs tableaux Lookup. Image 3-2 montre la structure de base
d'un FPGA, une explication détaillée suivra plus tard.
F1
F2
F3
F4
D
>CLK
CE
Q
F
Image 3-2 Conception de base d'un FPGA
Technologie des circuits intégrés FPGA Bsiss Mohammed
40
3.3.3 Les blocs logiques configurables (CLB)
Le CLB est l'élément fonctionnel de base de ce FPGA. Sa programmation permet à
l'utilisateur de réaliser des fonctions logiques combinatoires ou séquentielles.
Ils sont disposés dans une géométrique, qui permet à une conception logique
combinatoire et séquentielles. Chaque élément est relié à une matrice de
commutation à fin de rendre les ressources de connexion plus rapide et plus
accessible. Le schéma bloc simplifié d'un CLB est représenté à la page suivante. Il
est constitué de 4 SLICES, qui sont eux-mêmes formés de deux cellules logiques.
TBUF X0Y1
TBUF X0Y0
COUT
COUT
CIN
CIN Fast
Connects
To neighbors
Switch
Matrix
Slice
X0Y0
Slice
X0Y1
Slice
X1Y0
Slice
X1Y1
Image 3-3 Les éléments d'un des blocs logiques configurables (CLB)
Un slice (figure précédente) est constitué essentiellement de 2 générateurs de
fonctions (LUT) F et G et de 2 bascules D, FFX et FFY.
LUT
F
SRL16CY
CY
MUXF5
MUXFx
ORCY
RAM1
6
LUT
G
SRL16
RAM1
6
Register
Register
LUT
F
Arithmetic
logic Image 3-4 Construction d'un élément (slices)
Technologie des circuits intégrés FPGA Bsiss Mohammed
41
Générateurs de fonctions
Les deux générateurs de fonctions F et G peuvent réaliser chacun n’importe quelle
fonction combinatoire de 4 variables. En combinant les LUT des différents slices du
CLB, il est aussi possible de réaliser des multiplexeurs à grand nombre d’entrées :
par exemple, un mux 4:1 dans un slice, un mux 16:1 dans un CLB ou encore un mux
32:1 dans deux CLB. La polyvalence du CLB est la meilleure manière d’améliorer la
vitesse de fonctionnement du système à réaliser.
Bascules
Ces générateurs de fonctions peuvent être connectés directement vers les sorties du
slice (sorties X et Y), ou bien être mis en mémoire par deux bascules D (sorties XQ
et YQ). Ces deux bascules ont la même horloge (CLK), le même signal de validation
(CE) et la même logique de mise à 0 ou de mise à 1 asynchrone (SR). L’état de
sortie de la bascule à la mise sous tension est programmable. Les deux bascules
peuvent être utilisées indépendamment (entrée sur BX et BY) ou à la suite des
générateurs de fonctions.
Configuration en ROM, RAM et registre à décalage
Tous les générateurs de fonctions F et G du CLB peuvent être utilisés comme des
ROM. En effet, chaque LUT est une ROM de 16 bits et on peut donc former au
maximum une ROM 128x1 dans un CLB. Chaque LUT des 2 Slices de gauche du
Technologie des circuits intégrés FPGA Bsiss Mohammed
42
CLB peut aussi être programmé en RAM (simple et double port) ainsi qu’en registre à
décalage.
Ainsi, on peut trouver au maximum dans un CLB :
4 mémoires 16x1 bits synchrones simple port,
2 mémoires 32x1 bits synchrones simple port,
1 mémoire 64x1 bits synchrone simple port,
2 mémoires 16x1 bits synchrones double port,
1 registre à décalage 64 bits.
Ces mémoires sont très rapides et elles ont l’avantage d’être situées au cœur de la
fonction à réaliser. Il n’y a donc pas de délais de routage. La mémoire synchrone est
avantageuse car elle est plus rapide et plus facilement exploitable que la mémoire
asynchrone. La mémoire double port possède deux ports (adresse, donnée,
contrôle) indépendants. Elle peut être utilisée pour réaliser des FIFO. Le contenu de
ces RAM ou de ces ROM peut être initialisé à la mise sous tension.
Logique de retenue rapide
Chaque slice contient une logique arithmétique dédiée pour générer rapidement une
retenue (carry). Cette logique dédiée accélère grandement toutes les opérations
arithmétiques telles que l’addition, la soustraction, l’accumulation, la comparaison
Elle accélère aussi la vitesse de fonctionnement des compteurs. Chaque slice peut
Technologie des circuits intégrés FPGA Bsiss Mohammed
43
être configuré comme un additionneur 2 bits avec retenue qui peut être étendu à
n’importe quelle taille avec d’autres CLB. La sortie retenue (COUT) est passée au
CLB se trouvant au-dessus. La retenue se propage en utilisant une interconnexion
directe.
3.3.4 Blocs d’entrée / de sortie (IOBS)
Des blocs d’entrée-sortie (IOB) configurables sont répartis sur toute la périphérie du
boîtier. Chaque IOB assure l'interface entre une broche d'entrée/sortie du boîtier et la
logique interne.
La figure suivante représente le schéma bloc simplifié d'un IOB.
Standards d’entrée/sortie supportés (en différentiel, il faut utiliser une paire d’IOB) :
Technologie des circuits intégrés FPGA Bsiss Mohammed
44
Caractéristiques d’entrée
Le signal sur la broche d'entrée (I/O pin) est amené vers les CLB soit directement via
le signal I, soit à travers une paire de bascules D (ou de latch) via IQ1 et IQ2. Les
caractéristiques de l'entrée de l’IOB sont les suivantes :
diodes de protection ESD,
résistance de "pull-up" ou "pull-down",
Contrôle de l’impédance d’entrée (DCI),
23 standards d’entrée (différentiels ou non),
horloge indépendante de la sortie,
Un délai de quelques ns peut-être inséré dans le chemin de la donnée
d'entrée pour compenser le retard de l’horloge,
Support du Double Data Rate pour écrire dans les SDRAM DDR.
Caractéristiques de sortie
Le signal de sortie peut être optionnellement inversé à l’intérieur de l’IOB et sortir
directement sur la broche ou bien être mis en mémoire par une paire de bascules D
actives sur un front. Les caractéristiques de la sortie d'un IOB sont les suivantes :
buffer 3 états piloté par une paire de bascules D,
sortie collecteur ouvert,
23 standards de sortie (différentiels ou non),
contrôle de "slew-rate" (rapide ou lent),
Contrôle de l’impédance de sortie (DCI),
Support du Double Data Rate pour lire dans les SDRAM DDR.
sortance de 24 mA max.
3.3.5 Mémoire FPGA
Tous les FPGA de la famille Spartan-3 incorporent des blocs de mémoire RAM
18kbits synchrones simple ou double ports (de 4 à 104 suivant la taille du circuit).
Les 4 modes suivants sont possibles :
Technologie des circuits intégrés FPGA Bsiss Mohammed
45
La RAM bloc est composé d'une RAM 18 kbit, qui est intégré dans la puce. Ainsi,
aucune LUT ne doit être utilisé, ce qui offre la possibilité de concevoir une mémoire
plus grande.
La RAM bloc peut être configuré.comme une partie du port simple ou double port,
Les options de configuration des 18 kbit bloc-RAM est indiquée au tableau 4 2.
Chaque BlockRAM peut être configuré dans les modes : 16kx1, 8kx2, 4kx4, 2kx8,
1kx16 et 512x32 en simple port ou double ports.
L’Image 3-5 montre une RAM à port unique avec une capacité de stockage de 18
Kbits / s.
DI
DIP
ADDR
WE
EN
SSR
>CLK
DO
DOP
18 Kbit Block SelectRAM
Image 3-5 Bloc de 18 KBit d’un RAM à port unique
Contrairement à la RAM à port unique le RAM á double port synchrone a deux
entrées et sorties, et deux bus d'adresse. Ceux-ci peuvent être configurés
séparément (Image 3-6).
Technologie des circuits intégrés FPGA Bsiss Mohammed
46
DIA
DIPA
ADDRA
WEA
ENA
SSRA
> CLKA
DOA
DOPA
18 Kbit Block SelectRAM
DIB
DIPB
ADDRB
WEB
ENB
SSRB
> CLKB
DOB
DOPB
Image 3-6 Bloc de 18 KBit d’un RAM à port binaire
3.3.6 Multiplexeur
Associé à chaque BlockRAM, on trouve un multiplieur 18x18 = 36 bits signé en
complément à 2 (ou 17x17 = 34 non signé).On les utilisent surtout pour effectuer des
opérations de traitement du signal, mais ils peuvent aussi être utilisés avec profit
pour réaliser des opérations logiques (comme un décalage en un coup d’horloge par
exemple).
L’Image 3-7 illustre l'interconnexion de la RAM avec le multiplexeur.
Technologie des circuits intégrés FPGA Bsiss Mohammed
47
18-Kbit block
SelectRAM
18
x 1
8 M
ultip
lier
Switch
Matrix
Switch
Matrix
Switch
Matrix
Switch
Matrix
Image 3-7 18x18 Multiplexeur
3.3.7 Gestionnaire d’horloges
Le FPGA possède un gestionnaire d’horloge (Digital Clock Manager : DCM)
particulièrement élaboré. Il permet par exemple de créer des horloges décalées en
phase (pour piloter des DDR SDRAM par exemple), ou encore il élimine le skew
(décalage des arrivées d’horloge sur les bascules D) des horloges dans le FPGA ou
bien encore il permet de synthétiser des horloges avec des rapports (M x Fin) / D
(avec M entier compris entre 2 et 32 et D entier compris entre 1 et 32). Vous pouvez
par exemple créer une horloge sur CLKFX dont la fréquence est égale à 11/7 de
CLKIN.
La structure de la gestion de l'horloge numérique est illustrée par la Image 4-13.
Technologie des circuits intégrés FPGA Bsiss Mohammed
48
DCM
CLKIN
CLKFB
RST
DSSEN
PSINCDEC
PSEN
PSCLK
CLK0
CLK90
CLK180
CLK270
CLK2X
CLK2X180
CLKDV
CLKFX CLKFX180
LOCKED
STATUS[7:0]
PSDONE
Image 3-8 Gestionnaire d’horloge numérique
D’autre part, le FPGA possède 8 buffers spéciaux (BUFG) pour distribuer les
horloges dans le circuit.
Technologie des circuits intégrés FPGA Bsiss Mohammed
49
4 Modélisation et Synthèse VHDL d’un processeur de
traitement du signal
Le chapitre suivant explique la structure d’un processeur qu’on veut le réaliser en
langage VHDL.Le microprocesseur pris comme exemple est un processeur de 16
bits de traitement du signal . Il contient un chemin de données optimisé pour le
traitement de signal en virgule fixe (figure ci-dessous).
MPX
PC
mémoire
l'unité de contrôle
4K x 16Bit
bus de données
bidirectionnel
signaux de
commande
IR
11Bit
16 Bit
Adresse Bus
ALU
Reset
OP
Le registre à
décalage
sta
tusre
gis
terN
Z
C
V
Accu
16 bit
16 bit
16 bit
16 bit
5 bit
4 bit
alu_x alu_y
alu_out
out_flags
in_flags
opcode
In_flags alu_out
out_flags databus
Accu_in
accu_alu accu_db
lddbldalu
clk
lddb ldalu ldflag ldop ldia ldpc incpc outpc mem_enable reading penable
outreg
ldop ldia
clk
rese
t
ldpc
clk
rese
t
clk
rese
t
outpc
mem_enable reading clk
Output
irbus
penable
clk
rese
t
11 bit
16 bit
4 bit
16 bit
Image 4-1 Conception de base d'un processeur simple
4.1 Architecture interne
L'architecture est du type Harvard optimisée pour des raisons de vitesse et de
flexibilité. Dans une stricte architecture Harvard, les mémoires programme et
données se trouvent dans deux endroits séparés permettant un chevauchement
temporel des opérations de recherche et d'exécution des instructions. La modification
de l'architecture Harvard dans le processeur permet le transfert entre les espaces
programme et données, et l'augmentation de la flexibilité. Cette modification
architecturale autorise le transfert des coefficients constants chargés dans la
mémoire programme vers la mémoire de données interne, ce qui permet d'éviter
Technologie des circuits intégrés FPGA Bsiss Mohammed
50
d'utiliser une mémoire de type ROM pour les stocker. La puissance de traitement est
maximisée en maintenant les deux bus séparés (programme et données) permettant
une exécution rapide. Le processeur implémente matériellement un certains nombre
de fonctions complexes que la plus part des autres processeurs implémentent en
microcode.
4.1.1 Unité arithmétique logique (ALU)
La tâche de l'unité arithmétique et logique (engl: arithmetic logical unit, court: ALU)
est le traitement et l'exécution des opérations arithmétiques et logiques. Dans une
unité logique, les deux entrées A et B sont reliés les uns aux autres en raison de
l'opérateur spécifié (Image. 5 2). Le résultat est preévu, à la sortie F. Les opérations
arithmétiques avec des équations complexes sont décomposées en équations
simples, qui ont au maximum deux opérandes.
L’Image 5-2 montre l'unité arithmétique logique (ALU) comme unprocesseur simple.
Le module ALU est conçu pour des opérandes de 16-bits de large. Le type
d'opération peut être défini dans ce module par l'affectation de cinq signaux de
contrôle.
ALU
B15A15 B0A0
S0S1S2S3
signaux de
contrôle
C O SZF15 F0
- - - - -- - - - -
- - - - -
Image 4-2 Additionneur complet du processeur simple
Pour assurer un traitement rapide et une analyse efficace de l'opération arithmétique
ALU sera soutenue par le registre d'état (Condition- Code-Register). C'est ce qu'on
appelle les registres de l'état et possede les quatre déclarations suivantes:
Le Carry-Bit C est réglé si le résultat d'une opération arithmétique génère un
Carry.
Le bit Zero “Z“ est défini, si le résultat est nul.
Le bit Overflow-Bit “O“ est défini lors d'une opération arithmétique a eu lieu à
un certain nombre de gamme (Le complément de deux).
Technologie des circuits intégrés FPGA Bsiss Mohammed
51
Le bit de signe “S“ est défini lorsque le résultat d'une opération représente un
nombre négatif dans le complément de deux.
Pour un processeur simple un accumulateur est utilisé pour l’entrée B. L'avantage
d'utiliser cette adresse est une de commande de version plus courte.
La raison de ceci est qu’au début d'une opération, le second opérande doit toujours
être dans l'accumulateur et donc pour une opération une seule adresse est
nécessaire. La structure d’une seule adresse (Akku :=Akku +A) est représenté par
l’image 5-3
accumulateur
ALU
registre 1
F
resultat
Operand A Operand B
Image 4-3 Schéma fonctionnel d'un processeur simple
En revanche, pour la structure d’une machine de deux adresses deux adresses sont
nécessaires pour le contenu du répertoire "A" et "B". Le diagramme de bloc d’une
machine de deux adresses (B: = A + B) est représenté par l’image
ALU
registre A
F
Operand A Operand B
registre B
rsultat
Image 4-4 Schéma fonctionnel d’une machine à deux adresses
Technologie des circuits intégrés FPGA Bsiss Mohammed
52
4.1.2 Registres
Les principales tâches du processeur de commande sont repri à quatre registres.
Ce sont:
Le registre à décalage
Le registre à décalage de 16 Bits sont passer les points d'un mot binaire d'une
position vers la gauche ou la droite. Cela correspond à une multiplication ou
une division par 2
L'accumulateur
Dans la machine d’une seule adresse l'accumulateur (Akku) est utilisé comme
un registre lecture ou d’écrture. Dans cette opération le 2ème Opérande se
trouve dans le registre. Le résultat sera transmis à l'accumulateur.
Le registre de commande
Le registre de commande se compose de commande (5 bits) et de décodeur
d'adresses (11 bits). Par conséquent, dans le registre d'instruction (IR =
Instruction Register) se trouve la commande actuelle à modifier. Ce travail
sera achevé tant qu’est entreposé jusqu'à son exécution.
Le compteur de programme:
Le compteur de programme (PC, programm counter) est utilisé pour accéder à
prochaine instruction machine. Pour une instriction machine ce-ci est
augmentée par un point et montre l'instruction machine suivante. Mais Lors
d’un branchement commandes, il est chargé avec une nouvelle adresse.
Technologie des circuits intégrés FPGA Bsiss Mohammed
53
4.1.3 Le système de bus
Le système de bus du processeur simple est constitué de trois parties:
le bus de données, qui envoie les données entre les différents composants du
processeur.
le bus d'adresse, qui est responsable du transfert d'adresses de mémoire.
et le bus de commande est responsable pour le contrôleur d'interruption,
commande de bus d'accès, le pointage, remis à zéro, et la gestion d'état.
Le nombre de lignes des adresses permet le calcul du maximum d’octets de
mémoire centrale adressable. Dans notre cas, le nombre de lignes d'adresse est
16.Cela se traduit dans la mémoire adressable 216 = 65536 bits.
L’image illustre le flux d'un processeur simple. On voit que par le bus de données la
mémoire principale, ALU est connecté avec le registre d'instruction. Les données
stockées dans la mémoire peuvent être acceder à l'ALU par le bus de données et y
peuvent être édités. Le résultat de cette opération est placé non seulement dans
l'accumulateur ou dans la mémoire, mais aussi peut être transmise au port de sortie
du processeur.
Entre la mémoire principale et le registre d'instruction se trouve le bus d'adresse.
Grâce au multiplexeur il est possible de reprendre l’adresse entre le registre de
commande (eng: instruction register. Court:IR) et le compteur de programme (engl
programcounter, court:PC). A la fin, les signaux de comande de la machine sont
générés dans l'unité de contrôle.
Technologie des circuits intégrés FPGA Bsiss Mohammed
54
MPX
PC
mémoire
l'unité de contrôle
4K x 16Bit
bus de données
bidirectionnel
Signaux de
commande
Clock
IR
12Bit
16 Bit
Adresse Bus
ALU
Reset
OP
Le registre à
décalage
N
Z
C
V
Accu
16 bit
16 bit
16 bit
16 bit
5 bit
4 bit
outreg
Output
16 bit
irbus
11 bit
Image 5-4-5 Architecture d'un processeur simple
Technologie des circuits intégrés FPGA Bsiss Mohammed
55
4.1.4 La mémoire principale (RAM)
Random Access Memory (RAM) signifie mémoire à accès aléatoire. C'est une
mémoire numérique pour stocker une information binaire. Tant que la puce mémoire
est alimentée pour électricité, ces données peuvent être relus ou écrite. Avec la
fermeture de l'électricité, les données sont perdues. Chaque cellule de mémoire est
connectée directement par son adresse mémoire. L'adresse mémoire est divisée en
plusieurs décodeurs et décodeurs colonne. Le nombre de bits qui peuvent être
stockés dans une adresse est déterminé par la largeur "la longuer du données."
On distingue généralement deux types de mémoire vive.
mémoires statiques à accès aléatoire SRAM
Dynamic Random Access Memories
Dans ce travail une mémoire centrale de SRAM est utilisée pour le processeur
simple. Ici la SRAM est consulté par plus de 11 lignes d'adresse. La capacité de
stockage totale est de 8192 octets (8 Kbyte), puisque chaque mot de mémoire a une
largeur de 16 bits. La plus petite unité d'accès à la mémoire centrale est de 16 Bit.
Technologie des circuits intégrés FPGA Bsiss Mohammed
56
5 Le processeur étudié
Dans ce chapitre on va étudier l'architecture d'un microcontrôleur synthétisables
(CPU) avec un bus de donné de 16 bits et un bus d’adresse de 11 bits.
La figure suivante représente le schéma du microcontrôleur:
MPX
PC
mémoire
l'unité de contrôle
4K x 16Bit
bus de données
bidirectionnel
signaux de
commande
IR
11Bit
16 Bit
Adresse Bus
ALU
Reset
OP
Le registre à
décalage
sta
tusre
gis
terN
Z
C
V
Accu
16 bit
16 bit
16 bit
16 bit
5 bit
4 bit
alu_x alu_y
alu_out
out_flags
in_flags
opcode
In_flags alu_out
out_flags databus
Accu_in
accu_alu accu_db
lddbldalu
clk
lddb ldalu ldflag ldop ldia ldpc incpc outpc mem_enable reading penable
outreg
ldop ldia
clk
rese
t
ldpcclk
rese
t
clk
rese
t
outpc
mem_enable reading clk
Output
irbus
penable
clk
rese
t
11 bit
16 bit
4 bit
16 bit
Image 6-5-1 Architecture d'un processeur simple avec des signaux de commande
Le microcontrôleur se compose des éléments suivants:
- Deux 16-enreistrement des données de bits, un accumulateur et registre à
décalage
Unité arithmétique logique (ALU)
Registre d´état (V, C, Z, n)
Registre de compteur d´instructions (PC)
compteur d´instructions
Opcode
Multiplexeur
L'unité de commande
Dansun mot-machine de 16 bit les 5 bits les plus élevé de la donné élémentaire
représentent l'opcode et les autres 11 bits représentent la partie adresse. Par la
Technologie des circuits intégrés FPGA Bsiss Mohammed
57
limitation à 11 bits le processeur simple peut s'attaquer à un espace d'adressage de
211Bit- mots de 16 bits. Le processeur prend en charge trois modes d'adressage:
solution des problèmes immédiats
adressage direct
et adressage indirect
La chaîne de développement du processeur avec l'objectif de mise en œuvre dans le
FPGA (xC2v500-6fg456) passe par l'étape suivante:
La saisie du code VHDL
• Création du code VHDL
• Intégration (instanciation) des composantes
La simulation
• Créer une norme Testbench VHDL
• Effectuer la simulation
• Analyse des résultats de la simulation
- La mise en œuvre
• Translate
• Mape
• Place and route
L'ébauche de la séquence du processeur du genre 1oo1 est représentée par
Image 5-2
Compile the codeWrite VHDL Code Simulate designImplement the
code in FPGA
Debug Syntax
Compile
Debug Design error
Image 5-2 Conception d'un processeur simple
Technologie des circuits intégrés FPGA Bsiss Mohammed
58
5.1 Le projet de l'unité arithmétique logique (ALU)
L'unité arithmétique logique pour effectuer une addition ou bien une subtraction de
deux valeurs de 16 bits, ainsi que les opérations logiques. En dehors de ALU la
glisse de la commande est configurée comme un composant externe. La décision
relative à cette opération qui doit être effectuée est déterminée par la partie
opérande.
Dans Image 5-3 suivante l'architecture de l'ALU du simple processeur est montrée
avec ses signaux de contrôle. Il s'agit d'une machine à une adresse.
l'unité de
contrôle
ALU
reset
Le registre à décalage
N
Z
C
V
Accu
16 bit
16 bit
16 bit
16 bit
4 bit
alu_x alu_y
alu_out
out_flags
in_flags
opcode
In_flags alu_out
out_flags databus
Accu_in
accu_alu accu_db
lddb
clk
ldaluldflag
4 bit
Bidirektionaler Data Bus16 Bit
5 bitOpcode Bus
clk
reset
Image 5-3 Construction d'une unité arithmétique et logique
Les opérations correspondantes sont contrôlées par un multiplexeur. Le tableau
suivant (tableau 6 1) contient à part que le nom de commande et son type
d´adressage ses encodage binaire ou hexadécimal, et les Etats d´indicateur:
Technologie des circuits intégrés FPGA Bsiss Mohammed
59
Tableau 5-1 Fonctions de l'unité arithmétique et logique
Opcode
Bits
Opcode
Hex
Commandes
Eclairci court
Le type
d’adressage
indicateur
V C Z N
0 0 0 0 1 01 SHLLB <-alu_out Décalage à gauche v c z n
0 0 0 1 0 02 SHLRB alu_out-> Décalage à droite - - z n
0 0 0 1 1 03 STAM Akku -> Memoric Absolute
enregistrer
- - - -
0 0 1 0 0 04 STAP Akku -> PortA Données de sortie - - - -
0 0 1 0 1 05 STAIND Akku -> (Memoric) Indirectement
enregistrer
- - - -
0 0 1 1 0 06 LDDM Daten -> Akku Mise en charge
immédiate
- - z n
0 0 1 1 1 07 LDMA Memoric -> Akku Charge absolute 0 0 z n
0 1 0 0 0 08 LDIND (Memoric) -> Akku Charge
indirectement
0 0 z n
0 1 0 0 1 09 ORB Akku or Memoric ->
Akku
or 0 0 z n
0 1 0 1 0 0A EORB Akku xor Memoric ->
Akku
xor 0 0 z n
0 1 0 1 1 0B ANDB Akku and Memoric ->
Akku
and g 0 0 z n
0 1 1 0 0 0C ADDB Akku + Memoric ->
Akku
Addition v c z n
0 1 1 0 1 0D SUBB Akku - Memoric ->
Akku
Subtraction v c z n
0 1 1 1 0 0E JMP saut absolut - - - -
0 1 1 1 1 0F JSR Subroutine - - - -
1 0 0 0 0 10 BRA_V Saut si VFLG = 1 v - - -
1 0 0 0 1 11 BRA_C Saut si CFLG = 1 - c - -
1 0 0 1 0 12 BRA_Z Saut si ZFLG = 1 - - z -
1 0 0 1 1 13 BRA_N Saut si NFLG = 1 - - - n
1 0 1 0 0 14 NOP Pas d‘Opération - - - -
1 0 1 0 1 15 EOP Fin d‘Opération - - - -
Technologie des circuits intégrés FPGA Bsiss Mohammed
60
L'ALU est également en mesure de procéder à l'expansion interne signée par le
calcul. En outre, les informations d'état sont visibles à l'aide des registres d'état à
l'extérieur. Ces débordements sonten détail, overflow, carry et et l´indicateur nul et
sont calculés comme ci suit:
- Le report de l´indicateur est calculé en relevant la ligne de données à 17 bits.
l´indicateur overflow est mis combinant les 17 et 16 bits avec Xor en-High.
l´indicateur négatif représente le dernier bit donnée du mot-machine
élémentaire (16 bits)
l´indicateur Zéro est défini si le résultat est zéro
L´image 6- 4 illustre les indicateurs sur la commande et son influence. On peut
constater que les opérations arithmétiques et les instructions décalage sont dans une
position d'influencer tous les indicateurs. Toutefois, les instructions de branchement
ne peuvent réagir uniquement avec certains indicateurs
N
Z
C
VADDB, SUBB, SHLLB
ADDB, SUBB, SHLLB
ADDB, SUBB, SHLLB, SHLRB,ANDB,LDMA,LDDM,LDIND
ADDB, SUBB, SHLLB, SHLRB,ANDB,LDMA,LDDM,LDIND BRA_N
BRA_Z
BRA_C, ADDB, SUBB
BRA_V
useinfluence
Image 5-4 Les indicateurs et leur effet sur les commandes
L'entité du code VHDL- ALU est mentionnée "alu". Tout signaux et les ports (in, out)
sont de types défini de type std_logic_vector, à l'exception du signal opcode ". Ceci
est définie par défaut en VHDL et peut prendre les valeurs ( 'U', 'X', '0 ', '1', 'Z', 'W',
'L', 'H','-'). Le signal d'opcode, cependant, appartient à enumeration et ne peut donc
accepter que certaines valeurs qui sont définies dans le bibliotheque
« work.cpupackage.all » ".
Avant d'utiliser le code VHDL ALU doit être inclus, toutefois, l'extension de la
bibliothèque, afin que le type standard défini dans l'Entité ou dans le code soit
utilisable.
Technologie des circuits intégrés FPGA Bsiss Mohammed
61
L'entité ALU est comme suit:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use WORK.CPUPACKAGE.ALL;
entity alu is
port(
alu_x : in std_logic_vector(data_width-1 downto 0);
alu_y : in std_logic_vector(data_width-1 downto 0);
opcode : in OPTYPE;
alu_out : out std_logic_vector(data_width-1 downto 0);
in_flags : in std_logic_vector(3 downto 0);
out_flags : out std_logic_vector(3 downto 0)
);
end entity alu;
Figure 5-1 Le code VHDL de l'ALU (entity)
Les modules des différentes opérations sont déclarés dans "architecture".
L'architecture, qui referencie l Entity "alu" áccompagné, s’appelé "Behavioral".
Les opérateurs logiques (ORB, ANDB, EORB) sont redéfinis en contenant du VHDL
(or, and, eor), et ne doivent pas être redéfini. En revanche, une nouvelle definition
des opérations arithmétiques "ADDB" "et "SUBB" est programmé.
Toutes ces déclarations entre "begin" et "end" sont déclarées et exécutées en
parallèle. L'architecture d’ALU est comme suit:
architecture Behavioral of ALU is
begin
ALU_PR : process (alu_x, alu_y, opcode)
variable v,c,z,n : std_logic;
alias n_flag_in : std_logic is in_flags(0);
alias z_flag_in : std_logic is in_flags(1);
alias c_flag_in : std_logic is in_flags(2);
alias v_flag_in : std_logic is in_flags(3);
variable zwe : std_logic_vector(data_width-1 downto 0);
variable result : std_logic_vector(data_width+1 downto 0);
Technologie des circuits intégrés FPGA Bsiss Mohammed
62
begin
case opcode is
when LDDM | LDMA | LDIND =>
zwe:= alu_x;
when ORB =>
zwe:=alu_x or alu_y;
c := c_flag_in;
v := v_flag_in;
when ANDB =>
zwe :=alu_x and alu_y;
c := c_flag_in;
v := v_flag_in;
when EORB =>
zwe:=alu_x xor alu_y;
c := c_flag_in;
v := v_flag_in;
when ADDB =>
result := add(alu_x,alu_y,c_flag_in);
zwe := result(data_width-1 downto 0);
v := result(data_width);
c := result(data_width+1);
when SUBB =>
result := sub(alu_x,alu_y,c_flag_in );
zwe := result(data_width-1 downto 0);
v := result(data_width);
c := result(data_width+1);
when others => null;
end case;
n := zwe(data_width-1);
z := set_if_zero(zwe(data_width-1 downto 0));
out_flags <= (v,c,z,n);
alu_out <= zwe ;
end process ALU_PR;
end Behavioral;
Figure 5-2 Le code VHDL de L'ALU (architecture)
Technologie des circuits intégrés FPGA Bsiss Mohammed
63
Grâce à un processus séquentiel le résultat de la "alu_out "ALU est calculé. Les
indicateurs, cependant, sont générés par une description algorithmique.
La liste du variable situe, dans les parenthèses après le mot process, à un rôle clé
dans l'exécution de certains des processus. Cela signifie que le processus sera
effectué que si une variable dans la liste de sensibilité change.
Le système ALU est donc équipé, comme déjà mentionné, non seulement de l'ALU,
mais aussi du registre à décalage et l'accumulateur (figure 6-7).
Le registre à décalage est responsable de l´instruction décalage. Le programme
VHDL du registre à décalage se compose, comme tout le code VHDL de deux
éléments:
L'entité avec le nom de registre à " décalage "
L'architecture avec le nom " behavioral ".
Le mot clé "Port " définit les signaux d'entrée et de sortie. "Alu_out' "in_flags" et
"opcode ".sont les signaux d’entree .En revanche à la sortie "alu_out" se trouve le
mot-machine, qui doit être poussé à travers le registre. L'opcode est un vecteur
d'entrée qui encode les commandes du registre de décalage à gauche (SHLLB) ou
décalage à droite (SHLRB). Un autre vecteur d'entrée est le "in_flags" qui signifie les
indicateurs d'entrée.
Le signal « data bus » est un vecteur de sortie avec la longueur du 16. Sa tâche est
de pousser les données sur le bus de données. En définitive, le signal "out_flags"
transmit les informations des indicateurs à l'ALU ou à l'unité de commande (figure 6 -
7).
Technologie des circuits intégrés FPGA Bsiss Mohammed
64
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use WORK.CPUPACKAGE.ALL;
entity décalage is
port (
alu_out : in std_logic_vector(data_width-1 downto 0);
in_flags : in std_logic_vector(3 downto 0);
opcode : in OPTYPE;
databus : out std_logic_vector(data_width-1 downto 0);
out_flags : out std_logic_vector(3 downto 0)
);
end décalage;
Figure 5-3 Le code VHDL du registre à décalage (Entité)
Le terme utilisé dans l'architecture de registre à décalage a été décrit par une
description comportementale algorithmique, consistant un processus unique.
Dans le processus, deux variables alu_out" et "opcode", sont transmis qui
déterminent le comportement du processus à travers des déclarations CASE (Figure
6 8).
Le signal, qui est située à l'entrée "alu_out ", doit être decalé à l'entrée opcode dans
le registre, en fonction de la commande "SHHLB" ou "SHLRB». Si ce n'est pas le
cas, il est renvoyé vers le signal de sortie "databus".
architecture behavioral of schiebregister is
begin
SHB_PR : process (alu_out,opcode)
variable zwe : std_logic_vector(data_width-1 downto 0);
variable v, c, z, n : std_logic;
alias n_flag_in : std_logic is in_flags(0);
alias z_flag_in : std_logic is in_flags(1);
alias c_flag_in : std_logic is in_flags(2);
alias v_flag_in : std_logic is in_flags(3);
begin
Technologie des circuits intégrés FPGA Bsiss Mohammed
65
case opcode is
when SHLLB =>
we := alu_out(data_width -2 downto 0) & '0';
n := zwe(data_width-1);
z := set_if_zero(zwe(data_width-1 downto 0));
c := zwe(data_width-1);
v := zwe(data_width-2) xor zwe(data_width-1 );
when SHLRB =>
zwe := alu_out(data_width-1) & alu_out (data_width-1 downto 1);
n := zwe (data_width-1);
z := set_if_zero(zwe(data_width-1 downto 0));
c := c_flag_in;
v := v_flag_in;
when others =>
zwe := alu_out(data_width-1 downto 0);
(v, c, z, n) := in_flags;
end case;
databus <= zwe;
out_flags <= (v, c, z, n);
end process SHB_PR;
end behavioral;
Figure 5-4 Le code VHDL du registre à décalage (architecture)
Contrairement à l'ALU et au registre à décalage le registrer accumulateur fonctionne
en sychronisation avec l´horloge. Lors d´ une instruction IF la remise à zéro (reset )
demandé se fait d’une manière asynchrone et puis suit le front d'horloge pertinents.
C'est là que la valeur de l'accumulateu peut être, soit sur le bus de données lorsque
LDDB = "1" ou sur l'entrée de l'ALU (alu_y) à ldalu = "1" (Figure 6 9).
Technologie des circuits intégrés FPGA Bsiss Mohammed
66
architecture Behavioral of accum is
begin
ACCU_PR : process(clk,reset)
begin
if reset='0' then
accudb <= x"0000";
elsif clk='1' and clk'event then
if ldalu = '1' then
accul <= accuin;
end if;
if lddb = '1' then
accudb <= accuin;
end if;
end if;
end process ACCU_PR;
end Behavioral;
Figure 5-5 Le code VHDL de l'accumulateur (architecture)
Pour la modélisation et la vérification des Alu_System une simulation à l´aide du
programme de simulation, Xilinx ISE 8.1i et ModelSim XE III 6.0 (Image 6 -10) a été
utilisée.
Technologie des circuits intégrés FPGA Bsiss Mohammed
67
Figure 5-6 Simulation d'ALU
D´abord, l'accumulateur est chargé avec la valeur 0x0007 (LDDM), puis la valeur
0x000A est déduite. Le résultat est à t = 698 ns dans l'accumulateur. Au front
montant du signal d'horloge, cette valeur est supprimée sur le bus de données
(LDDB = '1 ').
À l'aide d'une LED à 7 segments la valeur qui se trouve sur l'accumulateur (0x0003)
est affichée. Noter que l'on ne peut pas afficher tout simplement "0011" pour voir le
numéro trois. L´image 6-6 montre la séquence des connexions à LED.
Technologie des circuits intégrés FPGA Bsiss Mohammed
68
g
a
d
bf
ce
Image 5-5 La forme de la LED à 7 -segments
Le processus VHDL pour l'affichage des résultats sur le LED de 7-segments est la
suivante:
APPLICATION_PR : process(accudb)
begin
if (accudb = "0000") then
seg_0 <= "0111111";--0
seg_1 <= "0111111";--0
elsif (accudb ="0001") then
seg_0 <= "0000110";--1
seg_1 <= "0111111";--0
elsif (accudb="0010") then
seg_0 <= "1011011";--2
seg_1 <= "0111111";--0
elsif (accudb="0011") then
seg_0 <= "1001111";--3
seg_1 <= "0111111";--0
….
….
….
end if;
end process APPLICATION_PR;
Figure 5-7 Le processus VHDL de l'accumulateur
Technologie des circuits intégrés FPGA Bsiss Mohammed
69
5.2 Disposition du compteurd´instructions, du registre de
commandes et du multiplexeur
En chapitre 5.2, le chemin de données a été géré. Un système ALU était joint,
composé de quatre éléments modélisés et mis en œuvre dans le dispositif FPGA
(xC2v500-6fg456). Dans ce chapitre, la section chargée de l´adressage de CPU sera
traité.
Il s'agit d'un composant unique (ir_pc), qui se compose d'un compteur d´instructions,
des registres de commandes et de multiplexeurs. Les données 16-bit mot est divisée
dans une 5-Bit opération et une section d'adresse 11-bit. (Image. 6-13).
MPX
PC
Bidirektional Data Bus
IR
11Bit
Adresse Bus
OP
5 bit
clk
ldpc
clk
rese
t
outpc
irbus
11 bit
16 bit
sig
na
ux d
e
co
mm
an
de
ldop
ldia
rese
t
incpc
clk reset
Opcode Bus
l'un
ité d
e c
on
trôle
Image 6-6 Le compteur d’instructions, le registre d'instruction et le multiplexeur
Le code VHDL de cette composante (ir_pc) se compose de quatre processus:
Le «processus OPCODE-PR" est un commutateur synchrone avec une
réinitialisation asynchrone. Le processus dépend à côté de l'horloge aussi du
signal de remise à zéro. Au front montant d'horloge des horloges à ldop = '1 ',
est décodé l'octet supérieur de la valeur actuelle du bus de données.
Le «processus LDADR PR" est un commutateur synchrone. Le processus
dépant que du signal "CLK“. Au front montant d'horloge et si en outre le signal
de sortie sont mis de "LDIA" à "High" (LDIA = '1 '); les bits 11 inférieure du mot
de données actuelles sont stockés dans le registre (IR).
Le processus de PC-PR est un 11 bits compteur de large, qui a une
réinitialisation asynchrone. L'adresse stockée dans le registre (IR) sera donee
dans le cas d'un pas en avant commande LDPC = '1 ' au compteur
d´instructions. L'adresse actuelle est incrémenté lorsque incpc = '1 '.
Technologie des circuits intégrés FPGA Bsiss Mohammed
70
Le processus de MULT-PR est un multiplexeur, , qui met en place sur l'entrée
de l'adresse du RAMS soit la section adresse dans le PC (outpc = '1 ') ou la
partie adresse de la commande en cours sur le bus de données.
Le code VHDL du compteur d´instructions, le registre d'instruction et le multiplexeur
est la suivante:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use WORK.CPUPACKAGE.ALL;
entity ir_pc is
port(
clk : in std_logic;
reset : in std_logic;
data : in std_logic_vector(data_width-1 downto 0);
ldop,ldia, incpc, ldpc,outpc : in std_logic;
opcode : out OPTYPE;
addrbus : out std_logic_vector(address_width-1 downto 0)
);
end ir_pc;
architecture Behavioral of ir_pc is
signal ir : std_logic_vector(address_width-1 downto 0);
signal pc : std_logic_vector(address_width-1 downto 0);
begin
OPCODE_PR : process(clk,reset)
begin
if reset = '0' then
opcode <= NOP;
elsif clk'event and clk='1' then
Technologie des circuits intégrés FPGA Bsiss Mohammed
71
if ldop='1' then
case data(data_width-1 downto data_width-5) is
when "00000" => opcode <= NOP;
when "00001" => opcode <= SHLLB;
when "00010" => opcode <= SHLRB;
when "00011" => opcode <= STAM;
when "00100" => opcode <= STAP;
when "00101" => opcode <= STAIND;
when "00110" => opcode <= LDDM;
when "00111" => opcode <= LDMA;
when "01000" => opcode <= LDIND;
when "01001" => opcode <= ORB;
when "01010" => opcode <= EORB;
when "01011" => opcode <= ANDB;
when "01100" => opcode <= ADDB;
when "01101" => opcode <= SUBB;
when "01110" => opcode <= JMP;
when "01111" => opcode <= JSR;
when "10000" => opcode <= BRA_V;
when "10001" => opcode <= BRA_C;
when "10010" => opcode <= BRA_Z;
when "10011" => opcode <= BRA_N;
when "10100" => opcode <= EOP;
when others => opcode <= NOP;
end case;
end if;
end if;
end process OPCODE_PR;
LDADR_PR : process(clk)
begin
if clk'event and clk='1' then
if ldia = '1' then --11 Bit Register
ir <= data(address_width-1 downto 0);
end if;
end if;
end process LDADR_PR;
Technologie des circuits intégrés FPGA Bsiss Mohammed
72
PC_PR: process(clk,reset)
begin
if reset='0' then--mit asynchronem Reset
pc <= (others =>'0');
elsif clk'event and clk='1' then
if ldpc='1' then--Vorladen
pc <= ir;
elsif incpc='1' then
pc <= pc + 1;
end if;
end if;
end process PC_PR;
MULT_PC : process(outpc,ir,pc)--12 Bit Mux
begin
if outpc='1' then
addrbus <= pc;
else
addrbus <= ir;
end if;
end process MULT_PC;
end Behavioral;
Figure 5-8 Le code VHDL du compteur de programme, le registre d'instruction et le
multiplexeur
Pour la modélisation et la vérification des processus individuels, la simulation de
l´image 6-15 a été réalisée.
Technologie des circuits intégrés FPGA Bsiss Mohammed
73
Figure 5-9 Simulation de composants ir_pc
Avec les signaux de validation. ldop = '1 'et LDIA = '1' le mot-machine est décodé au
second bord d'horloge positive du signal d’horloge, le signal résultant avec opcode
"shllb" et le bus d'adresse sont remplis de «0x003». D'autres part, le bus d'adresse
sera charger à la quatrième lisière de l'horloge positive du signal d'horloge et de la
validation outpc = '1 'avec l'adresse à base du compteur d´instructions (0x002).
5.3 Conception d’une unité de contrôle
Après que la partie des bus de données et d’adresse ont été traités, sera illustrée
maintenant la partie qui est responsable de la gestion des composants.
Technologie des circuits intégrés FPGA Bsiss Mohammed
74
Systématiquement, la queue doit être mis en œuvre en tant que FSM (finite state
machine), car il est charge de tous les signaux les statuts et de contrôle qui sont
responsable d’entrée et de sortie pour toutes les commandes. Cela devrait être
conçu comme une machine de Mealy, c'est à dire que les signaux de commande
sont depent de l'État et les entrées de l'unité de contrôle.
Dans le processus déposition il est au début très important que les commandes
soient analysées en fonction de leur cycle d'horloge. Voici trois catégories:
Une commande à cycle unique dont la performance s´effectue à deux temps
dans un front d'horloge. En même temps, la prochaine commande sera lue.
Cette catégorie inclut les instructions de décalage (SHLLB, SHLRB), la
commande NOP (no operation) et la commande EOP (end of operation).
Les commandes à deux cycles nécessitent une seconde barre pour lire le mot
de machine du second opérande de mémoire ou bien de déclencher un saut.
Cette catégorie comprend les commandes suivantes (STAM, STAP, LDDM,
LDMA, ORB, et ANDB, addb, Subb, JMP, JSR, BRA_V, BRA_C, BRA_V,
BRA_N).
Les commandes à trois cycles nécessitent un troisième cycle du signal
d'horloge pour effectuer l'adressage indirect. Cette catégorie comprent les
commandes suivantes (STAIND et LDIND).
Le code VHDL de l’unité de contrôle est divisé en deux modèles de processus:
Le processus de la mémoire de l'état (SPEICHER_PR):
Cela fournit une commutation à séquences synchrone à une réinitialisation
asynchrone (Figure 6 16). Cela rend possible que dans le bord positif de
l'horloge du signal d'horloge, la reprise du signal d'état suivant a lieu. L'état
initial est caractérisé par l'état «ready».
Technologie des circuits intégrés FPGA Bsiss Mohammed
75
SPEICHER_PR : process(clk12,reset)
begin
if reset = '0' then
state <= ready;
elsif clk12'EVENT and clk12='1' then
state <= next_state;
end if;
end process SPEICHER_PR;
Figure 5-10 Le processus de stockage d’unité de contrôle
Le processus logique (CPUBM_PR):
Ceci est responsable pour le calcul des états ultérieurs et les signaux de
sortie. Le comportement du processus est déterminé par la déclaration de cas,
qui interroge les cinq états (prêt, fetch, get01, get02 et arrivée), (Figure6 9)
CPUBM_PR:process(state,operation)
….. Siehe VHDL-Code auf dem CD
case state is
….. when ready =>
…..Siehe VHDL-Code auf dem CD
when fetch =>
…..Siehe VHDL-Code auf dem CD
when get01 =>
…..Siehe VHDL-Code auf dem CD
when get02 =>
…..Siehe VHDL-Code auf dem CD
when finish =>
….. Siehe VHDL-Code auf dem CD
end case; end process CPUBM_PR;
Figure 5-11 Le processus logique d’unité de contrôle
Technologie des circuits intégrés FPGA Bsiss Mohammed
76
Dans la figure 6.-18 le diagramme d'états avec les cinq états est affiché:
ready
fetchmem_enable
Reading
addrbus
get02
finish
get01Alu_x
Alu_y
operation
operation = LDIND
&
Operation = STAIND
operation = EOP
Image 5-7 Diagramme d'état de l'unité de commande
L´unité de commande fonctionne selon le schéma de "Attente de la commande, "Get-
Command", "command-decode", "Run Command" et "New Command-get". L´image
6 -7 montre le diagramme d'état de l'unité de contrôle, qui se compose de cinq états.
Le traitement de la commande a lieu dans l´état "fetch" et l'exécution de commandes
aura lieu dans les états "get01" et "get02". Au cours de la phase d'exécution, les
signaux de commande seront générés pour l'exécution de la commande. Elles sont
indiquées dans le tableau 6 -3 Dans l'état finish le travail du processeur
estinterrompu. Ceci est fait pour la commande d'arrêt "eof" (end of operation).
Dans le Tableau 6 -3 sont affichées les commandes avec leurs signaux de
commande correspondants.
Technologie des circuits intégrés FPGA Bsiss Mohammed
77
Tableau 5-2 Tableau de commutation pour l'unité de contrôle
OPCODE
ld-
ia
ld-
op
ld-
pc
inc-
pc
ld-
flag
out-
pc
ld-
alu
ld-
db
mem_
enable
read-
ing
pn-
able
STATE
SHLLB 1 1 0 0 1 0 1 0 1 1 0 fetch
SHLRB 1 1 0 0 1 0 1 0 1 1 0 fetch
STAM 0 0 0 0 0 0 0 1 1 1 0 fetch
STAP 0 0 0 0 0 0 0 1 0 0 1 fetch
STAIND 1 0 0 0 1 0 0 0 1 1 0 get02
LDDM 0 0 0 1 1 1 1 0 1 1 0 fetch
LDMA 1 1 0 0 1 0 1 0 1 1 0 fetch
LDIND 1 0 0 0 1 0 0 0 1 1 0 get02
ORB 1 1 0 0 1 0 1 0 1 1 0 fetch
EORB 1 1 0 0 1 0 1 0 1 1 0 fetch
ANDB 1 1 0 0 1 0 1 0 1 1 0 fetch
ADDB 1 1 0 0 1 0 1 0 1 1 0 fetch
SUBB 1 1 0 0 1 0 1 0 1 1 0 fetch
JMP 0 0 1 0 0 1 0 0 1 1 0 fetch
JSR 0 0 1 0 0 1 0 0 1 1 0 fetch
BRA_V 0 0 1 0 1 1 0 0 1 1 0 fetch
BRA_C 0 0 1 0 1 1 0 0 1 1 0 fetch
BRA_Z 0 0 1 0 1 1 0 0 1 1 0 fetch
BRA_N 0 0 1 0 1 1 0 0 1 1 0 fetch
NOP 0 0 0 0 0 0 0 0 0 0 0 fetch
EOP 0 0 0 0 0 0 0 0 0 0 0 fetch
5.4 Conception de la RAM
La mémoire centrale de la machine simple est consultée par plus de 11 lignes
d'adresse. Le résultat est que 211 mots peuvent être abordés. Ainsi, la capacité totale
de stockage de la mémoire, est de 8192 octets (8 Ko) car chaque mot de mémoire a
une largeur de 16 bits. Seulement 16 x 16 bit de la RAM sont traités.Dans l´image
6-19 est indiquée le module le plus utilisé de RAM dans le CPU. Il sagit d’un
distributé-RAM, qui est généré à partir de cellules de logique ordinaires. L'avantage
d'une telle RAM interne (par rapport au bloc de RAM) est dans l'augmentation du
temps d'accès, ce qui favorise finalement une grande puissance de traitement.
L’utilisation d’un bloc de mémoire l’attribut syn_ramstyle doit être déclaré dans le
Technologie des circuits intégrés FPGA Bsiss Mohammed
78
code VHDL du RAMS. Une telle déclaration est la suivante:
attribut syn_ramstyle: string;
syn_ramstyle attribut de la mémoire: le signal est "block_ram";
16 X 16 Bit Distributed RAM
mem_enable
reading
addr
Data_in
Data_out>clk
Image 5-5 16 X 16 Bit Distributed-RAM d’une machine simple
Dans le tableau 6-4 les signaux RAM sont expliqués.
Tableau 5-3 Les signaux de contrôle de la mémoire principale
Signal de
commande
Explication
Clock déterminer le moment où une adresse est copié dans la mémoire
principale sur le bus de données
mem_enable Active le module RAM
reading La RAM est lu lors reading = '1 'et écrit lors reading='0'
addr sur ce bus l'adresse de RAM est à traiter
data_in sur ce bus, les données en RAM pour être écrites
data_out sur ce bus, les données sont lues à partir de la RAM
L'entité de code VHDL du module de RAM est constitué des signaux d'entrée "CLK",
"mem_enable","reading" les signaux vectoriels d'entrée, "addr", "data_in" et des
signaux vectoriels de sortie "data_out" (Figure 6 11). Le module de mémoire RAM
peut être consulté avec une longueur de mot de 16 bits et une largeur d'adresse de
11 bits. Celle-ci sont paramétrées par les capacités de mémoire réglable
„adress_width“ et „data_width. L'entité RAM est le suivant:
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_signed.all;
use WORK.CPUPACKAGE.ALL;
Technologie des circuits intégrés FPGA Bsiss Mohammed
79
entity mem is
port(
clk : in std_logic;
mem_enable : in std_logic;
reading : in std_logic;
addr : in std_logic_vector((address_width-1) downto 0);
data_in : in std_logic_vector((data_width-1) downto 0);
data_out : out std_logic_vector((data_width-1) downto 0)
);
end mem ;
Figure 5-12 Le code VHDL de memoire (Entité)
Le «processus de MEMO_PR" (Figure 6 12) décrit la fonctionnalité de lecture et de
l'écriture du module de mémoire. Cela a été déclaré dans la section architecture. La
matrice de mémoire est définie comme un champ de type "array". La profondeur de
la mémoire est modifié par le paramètre ajustable "mem_depth", qui est déclarée
dans le cpupackage.vhdl ". Avec le signal de commande "mem_enable» ou «lecture»
détermine si les données ont été écrites dans la mémoire (lecture = "0") ou lu de lui
(= lecture, 1).
architecture Behavioral of mem is
type MEM_TYPE is array(0 to mem_depth-1 ) of std_logic_vector (data_width-
1 downto 0);
signal memory : MEM_TYPE := (
b"0011100000000001", -- memoric(0)
b"0000000000000011", -- memoric(1)
b"0110000000000011", -- memoric(2)
b"0000000000000100", -- memoric(3)
b"0010000000000000", -- memoric(4)
b"0000000000000000", -- memoric(5)
b"1010100000000000", -- memoric(6)
b"0000000000000000", -- memoric(7)
b"0000000000000000", -- memoric(8)
b"0000000000000000" -- memoric(F)
);
--attribute syn_ramstyle : string;
--attribute syn_ramstyle of memory : signal is "block_ram";
Technologie des circuits intégrés FPGA Bsiss Mohammed
80
begin
MEMO_PR : process(clk,mem_enable, reading ,addr,data_in)
variable ADR_VAR : integer range 0 to mem_depth-1;
begin
if clk'event and clk='0' then
if (mem_enable='1') then
ADR_VAR:=conv_integer(addr);
if(reading = '0') then
memory(ADR_VAR) <= data_in;
else
data_out <= memory(ADR_VAR);
end if;
else
data_out <= (others => 'Z');
end if;
end if;
end process MEMO_PR;
end Behavioral;
Figure 5-13 Le code VHDL de la mémoire (architecture)
5.5 Conception du systeme complet
Un critère important pour la conception de l'ensemble du système est la condition
que le processeur et la RAM devraient être opérée à front d’horloge différente du
signal d'horloge. Autrement dit, les données de la mémoire adressée en RAM sont
utilisées comme le bord négatif du signal d'horloge sur le bus de données, et au front
positif du signal Cloke générée par le processeur.
L image 6-9 montre comment le processeur est instancié avec module de mémoire et
le port de sortie. La machine fonctionne avec une fréquence d'horloge de 2,14 MHz.
Technologie des circuits intégrés FPGA Bsiss Mohammed
81
mem_enable
reading
addr
Data_in
Data_out
>clk
CPU
I/O
RAM
penable
Image 5-9 Interaction de la CPU, la RAM et I/O registre
Le programme du processeur simple traverse différentes étapes, allant de decodage
des commandes jusqu'au le traitemant des commandes. Dans le chapitre suivant ce
processus sera illustre à la base d'un code de programme.
ldma (0x0006); memoric(0x7) ->AKKU
addb 0x0006, (0x0003); AKKU + memoric (0x8) -> AKKU
stam (0x0009); AKKU ->memoric (0xF)
eop;
5.5.1 La structure de commande
Les instructions machine indiquent quelle est l'opération dirigée par les données de
mot (opérandes) et où le résultat doit être sauvé. Les commandes sont une
instruction à une adresse, qui se compose de deux parties:
L'opération fait partie du genre d’opération (opération "opcode").
Partie opérande spécifie l'adresse d'un opérande. Dans le cas d’une
commande de cycle àdeux temps, l'autre opérande doit être chargé dans
l'accumulateur. Le résultat se trouve après l'opération dans l'accumulateur.
Image 6-7 illustre la structure de commandement du processeur simple.
Technologie des circuits intégrés FPGA Bsiss Mohammed
82
opérande partie opération
0111215
Figure 5-6 La structure de commandement du processeur simple
5.5.2 La commande de décodage
La commande de décodage à lieu au composant "ir_pc", tandis que le code de
commande est décodé au front d'horloge Ainsi, les signaux de commande
correspondants sont générés par l'unité de commande pour les composants
matériels divers (ALU, ACCU, etc.)
Pendant que lors des commandes "EOP" et "NOP" aucun signal de commande de
matériel n’est produit, les commandes "ldma" et "addb" passent dans leur exécution
dans le processeur plusieurs étapes:
ldma (0x0006):
1. Connectez l'accumulateur et le bus de données avec l’ALU
2. Incrémentez le compteur programme
3. Chargez l'entrée d'adresse de mémoire avec l'adresse de la charge opérande
(LDIA = '1 ')
4. Ajustez l’ALU au ldma"
5. Stockez le résultat à l’accumulateur (alu = 1 ')
6. Les Flagsbits en correspondance à l'ensemble de résultats (ldflag = "1")
addb AKKU(contenu d’une adresse):
La commande "addb" exécute la même démarche que dans la commande "ldma" .La
différence est que l’ALU est défini à l'opération "addb".
Technologie des circuits intégrés FPGA Bsiss Mohammed
83
Stam (0x0009):
1. Stockez le bus de données avec le contenu d’AKK
2. Connectez l'entrée d'adresse de mémoire avec l'adresse de mot de données
3. Stockez la valeur du bus de données dans la banque d'adresse en mémoire
5.5.3 L'exécution de commandes
Dans cette architecture, les commandes se trouvent, avec les données sur la
mémoire. Les codes binaires dans la mémoire peuvent être des commandes, de
données ou des adresses. Elles ne peuvent être obtenus grâce au déroulement du
programme.Sur la base de l'unité de contrôle, le CPU est en mesure d’un côté de
choisir le déroulement par le temps et d’autre côté lui-même, pour interpréter un mot
machine en mémoire.
Le déroulement par le temp est déterminé par les cinq états de la mission de
contrôle. Quand l’état de départ "ready" vient, le CPU va directement à récupérer
l’état "fetch".
Avec le début de la phase "fetch" la valeur actuelle du compteur d’instructions est
chargé dans le bus d'adresse et à un "augmenté". Le mot machine qui est stocké
sous cette adresse dans la mémoire est chargé dans le registre d'instruction. Au
cours de la phase de fetch, l'ALU et le registre à décalage n’ont pas de fonctionne.
Dans la phase d'exécution (get01 et get02) les mots machine stockée seront
interprétés dans instruction register. Si un opérande est récupéré de la mémoire, telle
qu’au "ldma" et "addb", l'adresse de l'opérande sera chargé dans l'entrée d'adresse
de mémoire. Sinon, le contenu du compteur d’instructions est chargé dans l'entrée
d'adresse de mémoire RAM qui. Par la suite, l'ALU exécute la commande.
La première commande dans le code du programme est de créer une commande de
chargement "ldma", c’est as dire l'accumulateur est chargé avec le contenu de
l'adresse (0x7). L'instruction d’addition "addb" ajouté au contenu de l'accumulateur le
contenu de l'adresse (0x8).
Le stockage du résultat ce fait par l’instruction mémoire "stma". En définitive, l'ordre
d'arrêt "EOP" (end of operation) est responsable pour finir le code du programme. La
Technologie des circuits intégrés FPGA Bsiss Mohammed
84
L’image 6-24 montre le cycle opératoire du du programme.
0000000011100111
0000000100001100
0000000111100011
0000000000010100
0000000000000000
0000000000000000
0000000000000000
0000000011000000
0000000001100000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
ldma (0x0006)
addb (0x0003)
stam (0x0009)
0000000011100111
0000000100001100
0000000111100011
0000000000010100
eop
Image 5-11 Un exemple de programme en code d’une machine simple
Pour leurs utilisations Les éléments précédemment déclarés (ALU, ACCU, etc)
doivent être instancié dans une unité de conception.Dans VHDL l’instanciation se
déroule de la manière suivante:
Technologie des circuits intégrés FPGA Bsiss Mohammed
85
begin --architecture of Behavior
Comp01: mem
port map(
clk => clk12,
mem_enable => mem_enable,
reading => reading,
addr => temp_add,--Addr
data_in => data_in,
data_ou t => data_out --Data
);
Comp02: alu
port map(
alu_x => data_out,
alu_y => temp_2,
opcode => operation,
alu_out => temp_0,
in_flags => flags_2,
out_flags => flags_0
);
…..
Comp07: outreg
port map(
clk => clk12,
reset => reset,
penable => penable,
d => data_in,
q => q
);
Figure 5-14 L'instanciation des composants du processeur 1oo1
5.6 La simulation du système complet
Pour réaliser la simulation du système complet un testbench du processeur 1oo1 a
été conçu. Les résultats de simulation (diagramme de chronométrage) sont montré
dans la figure 6-15 ci-suit.
Technologie des circuits intégrés FPGA Bsiss Mohammed
86
Figure 5-15 Simulation de la CPU
Dans le second bord d'horloge positive du signal d'horloge périodique (T = 400 ns),
la première commande est décodé (ldma). La valeur attachée à la mémoire
d'adresse "007" est donc chargée dans l'accumulateur. À partir du temp T = 1.6, la
deuxième commande est décodée. Il s’agit d'instructions arithmétiques, qui doivent
ajouter au contenu de l'accumulateur, le contenu de la mémoire d'adresse (008). En
définitive, le résultat („0009") au temps t = 3.1 nous est stocké dans l'adresse (00F).
Apès avoir assuré que le circuit répond aux exigences recherchées, c'est à dire la
simulation ne fournit plus d'erreurs, le code VHDL est la synthèlisé et chargé dans le
FPGA.
À côté du FPGA (xc2v500-6fg456), le board contient douze LEDs à 7 segments, qui
sont connectés au dispositif FPGA. Cela permet de tester le code VHDL.
Technologie des circuits intégrés FPGA Bsiss Mohammed
87
5.7 Liste des figures
Figure 2-1 Syntaxe de la déclaration d'Entité ............................................................. 9
Figure 2-2 Syntaxe de la déclaration d'architecture .................................................... 9
Figure 2-3 Syntaxe de la déclaration des ports ........................................................ 11
Figure 2-4 Syntaxe de la déclaration générique ................ Erreur ! Signet non défini.
Figure 2-5 Définition du type de données .......................... Erreur ! Signet non défini.
Figure 2-6 Types de données défini par l’utilisateur ................................................. 13
Figure 2-7 Types de données défini par l’utilisateur ................................................. 13
Figure 2-8 Syntaxe de la déclaration de type .................... Erreur ! Signet non défini.
Figure 2-9 Types de données défini par l’utilisateur .......... Erreur ! Signet non défini.
Figure 2-10 Syntaxe des types entiers ..................................................................... 14
Figure 2-11 Syntaxe des types physiques ................................................................ 15
Figure 2-12 Declaration des tableaux à une dimension ............................................ 15
Figure 2-13 Déclaration des tableaux multidimensionnels ........................................ 15
Figure 2-14 : Déclaration d’un processus .......................... Erreur ! Signet non défini.
Image 4-1 Disposition des blocs logiques dans les FPGA et PLDErreur ! Signet non
défini.
Image 4-2 Conception de base d'un FPGA .............................................................. 39
Image 4-3 Architecture Virtex-II ................................................................................ 37
Image 4-4 Les éléments d'un des blocs logiques configurables (CLB) ..................... 40
Image 4-5 Construction d'un élément (slices) ........................................................... 40
Image 4-6 Éléments sclices de la famille Virtex-II en détailErreur ! Signet non
défini.
Image 4-7 LVTTL, LVCMOS or PCI select I/O .................. Erreur ! Signet non défini.
Image 4-8 Bloc de 18 KBit d’un RAM à port unique ................................................. 45
Image 4-9 Bloc de 18 KBit d’un RAM à port binaire ................................................. 46
Image 4-10 RAM distribué (RAM 16x1S)........................... Erreur ! Signet non défini.
Image 4-11 Port binaire du RAM distribué (RAM 16x1D) .. Erreur ! Signet non défini.
Image 4-12 18x18 Multiplexeur ................................................................................ 47
Image 4-13 Gestionnaire d’horloge numérique ......................................................... 48
Image 5-1 Conception de base d'un processeur simple ........................................... 49
Image 5-2 Additionneur complet du processeur simple ............................................ 50
Image 5-3 Schéma fonctionnel d'un processeur simple ........................................... 51
Image 5-4 Schéma fonctionnel d’une machine à deux adresses .............................. 51
Image 5-5-5 Architecture d'un processeur simple ..................................................... 54
Image 6-6-1 Architecture d'un processeur simple avec des signaux de commande 56
Image 6-2 Conception d'un processeur simple ......................................................... 57
Image 6-3 Construction d'une unité arithmétique et logique ..................................... 58
Image 6-4 Les indicateurs et leur effet sur les commandes...................................... 60
Technologie des circuits intégrés FPGA Bsiss Mohammed
88
Image 6-5 16 X 16 Bit Distributed-RAM d’une machine simple ................................ 78
Figure 6-6 La structure de commandement du processeur simple ........................... 82
Technologie des circuits intégrés FPGA Bsiss Mohammed
89
5.8 Liste des tableaux
Tableau 2-1 Modus du port Erreur ! Signet non défini.
Tableau 4-1 Technologie de stockage 36
Tableau 4-2 Nombre de tableaux Lookup dans RAM Erreur ! Signet non défini.
Tableau 4-3 entrées / sorties des Distributed-RAMs Erreur ! Signet non défini.
Tableau 6-1 Fonctions de l'unité arithmétique et logique 59
Tableau 6-2 Tableau de commutation pour l'unité de contrôle 77
Tableau 6-3 Les signaux de contrôle de la mémoire principale 78