Technologie des circuits numériques FPGA Le …© les circuits...numériques intégrés FPGA et le langage de programmation du matériel VHDL pour les étudiants de la Faculté de

Technologie des circuits intégrés FPGA Bsiss Mohammed

1

Département Génie Électrique

Technologie des circuits numériques FPGA &

Le langage VHDL


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.


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


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ínstructions, 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


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.


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.


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).


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)


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éntité > is

(generic <Déclaration des paramètres)>;

(port <Déclaration d’entrée/sortie>]

(local Déclaration)

End <nom déntité>

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.


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


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;


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


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íntérieur d’entité.

- À línté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)


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áutre 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


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.


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.


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.


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;


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;


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


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


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.


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.


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 :


24

2.1.3 Exemples commentés de circuits logiques multiplexeurs


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 ;


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,


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) ;.


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


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 :


30


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,…).


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


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.


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


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ínté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ímpulsions (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


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ún

processeur Power PC intégré FPGA avec les standards 1/0 les plus rapides et des

bibliothèques dínterface sur le marché. Pour léssentiel 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ún redémamage.


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),


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úne dénsemble. 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ést 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 :


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


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)


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


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


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) :


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 :


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).


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.


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.


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.


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


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).


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


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.


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.


54

MPX

PC

mémoire


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


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.


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


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ínstructions (PC)

compteur dínstructions

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


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


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ádressage ses encodage binaire ou hexadécimal, et les Etats díndicateur:


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 - - - -


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índicateur nul et

sont calculés comme ci suit:

- Le report de líndicateur est calculé en relevant la ligne de données à 17 bits.

líndicateur overflow est mis combinant les 17 et 16 bits avec Xor en-High.

líndicateur négatif représente le dernier bit donnée du mot-machine

élémentaire (16 bits)

líndicateur Zéro est défini si le résultat est zéro

Límage 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.


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);


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)


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ínstruction 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).


64

library IEEE;





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


65

case opcode is

when SHLLB =>

we := alu_out(data_width -2 downto 0) & '0';

n := zwe(data_width-1);


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);


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).


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áide du

programme de simulation, Xilinx ISE 8.1i et ModelSim XE III 6.0 (Image 6 -10) a été

utilisée.


67

Figure 5-6 Simulation d'ALU

Dábord, 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ímage 6-6 montre la séquence des connexions à LED.


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


69

5.2 Disposition du compteurdínstructions, 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ádressage de CPU sera

traité.

Il s'agit d'un composant unique (ir_pc), qui se compose d'un compteur dínstructions,

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ínstructions. L'adresse actuelle est incrémenté lorsque incpc = '1 '.


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ínstructions, le registre d'instruction et le multiplexeur

est la suivante:

library IEEE;





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


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;


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ímage 6-15 a été réalisée.


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ínstructions (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.


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éffectue à 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».


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 =>


when get01 =>


when get02 =>


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


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únité de commande fonctionne selon le schéma de "Attente de la commande, "Get-

Command", "command-decode", "Run Command" et "New Command-get". Límage

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.


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ímage

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


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_signed.all;



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";


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.


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.


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".


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


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:


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.


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.


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


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


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

Documents

Technologie des circuits numériques FPGA Le …© les circuits...numériques intégrés FPGA et le langage de programmation du matériel VHDL pour les étudiants de la Faculté de