FPGA EEIN

VHSIC : Very High-Speed Integrated Circuits

HDL : Hardware Description Language

A. Jilbab Page 1
 FPGA EEIN

Sommaire
I. Les circuits programmables ............................................................................................................ 3
1. Généralités .................................................................................................................................. 3
2. Les FPGA...................................................................................................................................... 4
3. Déroulement de la conception ................................................................................................... 5
II. La programmation VHDL ................................................................................................................. 6
1. Introduction ................................................................................................................................ 6
2. Entité et architecture .................................................................................................................. 6
3. Structure d’un programme VHDL ............................................................................................... 7
III. Manipulation des données en VHDL........................................................................................... 8
1. Données traitées par VHDL ......................................................................................................... 8
2. Les types en VHDL ....................................................................................................................... 8
3. Les opérateurs............................................................................................................................. 9
4. Les signaux .................................................................................................................................. 9
5. Les processus (process)............................................................................................................. 10
6. Résumé d’instructions .............................................................................................................. 11
IV. Les premiers PAS en VHDL ........................................................................................................ 13
Initiation à la programmation sous ISE de chez Xilinx ...................................................................... 13
Implémentation sur FPGA ................................................................................................................. 16
V. Description comportementale et structurelle .............................................................................. 20
Additionneurs ................................................................................................................................... 20
Compteurs......................................................................................................................................... 21
Registre à Décalage ........................................................................................................................... 22
VI. Les machines à états ................................................................................................................. 24
Les automates de Moore .................................................................................................................. 24

A. Jilbab Page 2
 FPGA EEIN

I. Les circuits programmables

1. Généralités
Les possibilités de conception des circuits numériques :

Circuits à architecture programmable :

 Apparition des premiers circuits vers les années 70 : premiers PLD-> PAL, GAL
 Evolution vers des composants plus complexes : CPLD, FPGA
 Différentes technologies pour la programmation des connexions
 Permanents, Volatiles statiques, Volatiles
 Capacité de programmation In-Situ
 composants dits ISP via interface JTAG
 Contexte de compétitivité mondiale
 Importance du Time-To-Market

A. Jilbab Page 3
 FPGA EEIN

2. Les FPGA
Granularité plus fine que les CPLD (macrocellules-complexes mais +nombreuses) avec un
réseau de routage réparti (non centralisé contrairement aux CPLD)

Intégration matérielle de composants supplémentaires

 RAM: appelé LUT (Look-Up Table)

 Mutiplexeurs divers
 PLL
 Multiplieurs câblés (FPGA haut de gamme => concurrence avec les DSP)

A. Jilbab Page 4
 FPGA EEIN

3. Déroulement de la conception

L’implémentation d’un circuit FPGA suit les étapes suivantes :

Spécification

Validation fonctionnelle

Design correct
non

oui

Validation temporelle

Spécifications
non temporelles

oui

Programmation

 Spécification : saisie du circuit logique (spécification syntaxique : VHDL, Verilog,

mode graphique, etc.)
 Validation fonctionnelle : simulation fonctionnelle du concept (problèmes des
sorites/sorties, boucles, etc.). Vérification ne prenant pas en compte les aspects
temporels du circuit
 Validation temporelle : Simulation temporelle (et fonctionnelle) du circuit (temps de
propagation, recouvrement de signaux, etc.).
 Implémentation : le programme est porté physiquement sur le circuit FPGA en
fonction des spécifications précisé par le programmeur (pins, etc.)

A. Jilbab Page 5
 FPGA EEIN

II. La programmation VHDL

1. Introduction

 Langage formel pour la spécification des systèmes digitaux, aussi bien au niveau
comportemental que structurel

 Les objectifs du langage VHDL

o Conception de circuits intégrés reconfigurable ou non (ASIC, FPGA…) :
SYNTHESE
o Mise au point de modèle de simulations numériques (circuits virtuels) :
MODELISATION

 Utilisation :
o description des systèmes
o Simulation
o aide à la conception
o documentation

 Caractéristiques principales :
o description à plusieurs niveaux
o simulation activée par événements (event-driven)
o Modularité
o Extensibilité
o langage général, fortement typé, similaire à Ada

 Le langage est capable de DECRIRE

o des comportements CONCURRENTS ( // )
o Des comportements séquentiels

Les deux portes

travaillent en //

2. Entité et architecture

 VHDL nous intéresse en tant que langage pour la description, simulation et synthèse
des systèmes digitaux

A. Jilbab Page 6
 FPGA EEIN
 Au plus haut niveau d’abstraction, un système digital est vu comme une “boîte noire”,
dont on connaît l’interface avec l’extérieur mais dont on ignore le contenu
 En VHDL la boîte noire est nommée entité (entity)
 Une entité doit toujours être associée avec au moins une description de son contenu,
de son implémentation : c’est l’architecture

3. Structure d’un programme VHDL

library ieee;
use ieee.std_logic_1164. all;
entity Telecom is
port (
Déclaration des
entrées/sorties ); Nom de
end Telecom; l’entité

architecture Reseau of Telecom is

Déclaration de
l’architecture
begin Nom de
Corps de l’architecture
l’architecture
end Reseau;

A. Jilbab Page 7
 FPGA EEIN

III. Manipulation des données en VHDL

1. Données traitées par VHDL
Toute donnée traitée par VHDL doit être déclarée comme constante, variable ou signal :

 Constantes :
constant pi : real := 3.1416;
constant index_max : integer is 10*N;

 Variables :
Valeur modifiable immédiatement par une affectation (:=)
variable stop : boolean;
variable etat : CodeDEtat := ST0;

 Signaux :
Modélisation de l’entrée/sortie d’un dispositif. C’est une forme d’onde qui change
avec le temps : la modification a lieu à la prochaine itération de la simulation (retard
delta)

2. Les types en VHDL

VHDL est un langage fortement typé : toute donnée doit être déclaré avant utilisation, en
indiquant son type. Les types prédéfinis sont :
 Scalaire
o integer
o real
o enumerated
o physical
 Composé
o array
o record
 Pointeur
o acces
 I/O
o File

On peut également créer de nouveaux types, en fonction des types prédéfinis, par exemple :
type HuitBits is range 0 to 255;
type CodeDEtat is (init, ST1, ST2, exit);
type word is array (0 to 31) of bit;
type EtatsLogiques is record
valeur : integer range -127 to 128;
force : integer;
end record;

Pour la synthèse, les types de données les plus utilisés sont std_logic, pour les données à un
bit, et std_logic_vector, pour les bus

A. Jilbab Page 8
 FPGA EEIN
Ces types ne sont pas prédéfinis : pour les utiliser, il faut déclarer le paquet (package)
std_logic_1164, qui fait partie de la bibliothèque (library) IEEE :
library ieee;
use ieee.std_logic_1164. all ;
use ieee.std_logic_unsigned. all ;

Une donnée de type std_logic possède une valeur parmi neuf possibles :
o 'U‘ uninitialized
o 'X’ forcing unknown
o '0’ forcing 0
o '1’ forcing 1
o 'Z’ high impedance
o 'W’ weak unknown
o 'L’ weak 0 (pull-down)
o 'H’ weak 1 (pull-up)
o '-’ don’t care
o Pour une affectation, les valeurs utilisées sont: 'X’, '0’, '1’, 'Z'

3. Les opérateurs
 Opérations logiques :
and or nand nor xor xnor
 Opérations de comparaison :
= /= < <= > >=
 Opérations de décalage
sll srl sla sra rol ror
 Opérations d’addition :
+ - &
 Opérations de signe :
+ -
 Opérations de multiplication :
* / mod rem
 Opérations diverses :
not abs **

4. Les signaux
Pour connecter les différents composants d’un système, VHDL utilise les signaux (signal),
équivalent des fils ou câbles d’interconnexion dans le monde réel. Exemple :
signal s : std_logic := '0';
•••
s <= '1’ after 10ns, '0’ after 18ns, '1’ after 25ns;

A. Jilbab Page 9
 FPGA EEIN

 On peut associer certains attributs aux signaux, qui produisent une valeur.
 Deux exemples d’attributs sont:
o s’ event :
vrai si un événement arrive pendant le delta présent (c’est-à-dire, si le
signal s change de valeur)

o s’ active:
vrai si une transaction arrive pendant le delta présent (c’est-à-dire, si le
signal s est évalué, qu’il change ou pas de valeur)

 Un signal est toujours global à une architecture donnée

5. Les processus (process)

 Une architecture en VHDL est un ensemble de processus exécutés en parallèle (en
concurrence)
 L’ordre relatif des processus à l’intérieur d’une architecture n’a pas d’importance
 Il existe deux types de processus:
 le processus implicite ou phrase concurrente
 le processus explicite
architecture toto of test is
begin
c <= a and b;
z <= c when oe='1‘ else 'Z';
Seq: process (clk, reset)
begin
:
end process;
end toto;

 Un processus explicite est un ensemble de phrases exécutées séquentiellement: à

l’intérieur d’un processus l’ordre des phrases a donc une importance

A. Jilbab Page 10
 FPGA EEIN
 Un processus ne peut pas être déclaré à l’intérieur d’un autre processus.

6. Résumé d’instructions

A. Jilbab Page 11
 FPGA EEIN

Exemples

A. Jilbab Page 12
 FPGA EEIN

IV. Les premiers PAS en VHDL

Initiation à la programmation sous ISE de chez Xilinx

On veut synthétiser le montage suivant en langage VHDL

 Lancer l’outil ISE et créer un nouveau projet

 Spécifier les caractéristiques de la cible:
o Spartan3E
o XC3S500E
o FG320

A. Jilbab Page 13
 FPGA EEIN

Ajout d’un fichier VHDL

• Sélectionner : "Project → New Source"

• On appellera notre fichier “exemple.vhd”

exemple.vhd

A. Jilbab Page 14
 FPGA EEIN
Configurer les ports d’entrées sorties selon l’entité souhaitée

Editer le programme suivant et vérifier sa synthèse

library ieee;
use ieee.std_logic_1164. all;
use ieee.std_logic_unsigned. all;
entity exemple is
port (a, b : in std_logic_vector(3 downto 0);
op, clk, reset : in std_logic;
c : out std_logic_vector(3 downto 0));
end exemple;
architecture test of exemple is
signal moinsb, opb, aopb : std_logic_vector(3 downto 0);
begin
moinsb <= not b + "0001";
opb <= b when op='0'
else moinsb;
aopb <= a + opb;
process (reset, clk)
begin
if reset='0'
then c <= "0000";
else if (clk’ event and clk='1')
then c <= aopb;
end if ;
end if ;
end process ;
end test ;
A. Jilbab Page 15
 FPGA EEIN

Implémentation sur FPGA

Objectif

Initiation au logiciel de CAO ISE pour l’implémentation sur circuit FPGA. Nous allons
écrire, en VHDL, un programme de base pour s’initier à charger une carte FPGA :

 Sur un afficheur 7 segments, on doit visualiser une valeur correspondante à la position

des Switches.
 On utilise les switches SW0 à SW3 pour représenter les 4 bits binaires.
 Les valeurs sont affichées en hexadécimal sur un afficheur 7 segments

Manipulation

 Lancer l’outil ISE et créer un nouveau projet

 Spécifier les caractéristiques de la cible:
o Spartan3E
o XC3S500E
o FG320
 Ajouter un fichier VHDL
o Sélectionner : "Project → New Source"
o On appellera notre fichier “toplevel.vhd”
 Faire la configuration de l’entité comme suit :

A. Jilbab Page 16
 FPGA EEIN
Le fichier généré automatiquement est le suivant :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity toplevel is
Port ( switches : in STD_LOGIC_VECTOR (3 downto 0);
sevenseg : out STD_LOGIC_VECTOR (6 downto 0);
anodes : out STD_LOGIC_VECTOR (3 downto 0));
end toplevel;
architecture Behavioral of toplevel is
begin
end Behavioral;

Compléter ce fichier par :

with switches select

sevenseg <=
"1000000" when x"0" ,
"1111001" when x"1" ,
"0100100" when x"2" ,
"0110000" when x"3" ,
"0011001" when x"4" ,
"0010010" when x"5" ,
"0000010" when x"6" ,
"1111000" when x"7" ,
"0000000" when x"8" ,
"0010000" when x"9" ,
"0001000" when x"A" ,
"0000011" when x"B" ,
"1000110" when x"C" ,
"0100001" when x"D" ,
"0000110" when x"E" ,
"0001110" when others;
anodes <= "1110";

A. Jilbab Page 17
 FPGA EEIN

Assignation des PINs de FPGA

 Cette étape permet de faire correspondre à nos entrées sorties des pins de FPGA
 Si on néglige cette étape, les pins sont assignés par le logiciel Xilinx aléatoirement
 Pour cela créer un nouveau fichier “Universal Constraints File” (.ucf).
o "Project → New Source"

Taper dans ce fichier les assignations suivantes :

NET “anodes<0>” LOC = “F17”;

NET “anodes<1>” LOC = “H17”;
NET “anodes<2>” LOC = “C18”;
NET “anodes<3>” LOC = “F15”;
NET “sevenseg<0>” LOC = “L18”;
NET “sevenseg<1>” LOC = “F18”;
NET “sevenseg<2>” LOC = “D17”;
NET “sevenseg<3>” LOC = “D16”;
NET “sevenseg<4>” LOC = “G14”;
NET “sevenseg<5>” LOC = “J17”;
NET “sevenseg<6>” LOC = “H14”;
NET “switches<0>” LOC = “G18”;
NET “switches<1>” LOC = “H18”;
NET “switches<2>” LOC = “K18”;
NET “switches<3>” LOC = “K17”;

A. Jilbab Page 18
 FPGA EEIN
Synthesis, Place+Route, Programming File

En double-cliquant sur “Generate Programming File” vous lancer la synthétise, le placement,

le routage et la génération du fichier programmation

Chargement de la cible

 Cliquer sur “Browse”

 Selectionner le fichier “toplevel.???“
 Cliquer sur “Program”

A. Jilbab Page 19
 FPGA EEIN

V. Description comportementale et structurelle

Additionneurs
Mettre en place un additionneur sur 4 bits. L’affichage des entrées ce fera dans un premier
temps sur des DEL puis sur des afficheurs 7 segments. L’objectif est de se familiariser avec les
fonctions, les procédures et les packages.

Additionneur 1 bit

 Implémenter en VHDL un additionneur 1 bit. Ce circuit doit comprendre

o Trois entrées : X (opérande1), Y (opérande2) et Cin (retenue en entrée)
o Deux sorties : S (résultat), Cout (retenue en sortie)
 Valider fonctionnellement et temporellement le circuit
 Implémenter le circuit sur le FPGA en lui
associant les composants suivants :
X Y
o X  SW0
o Y  SW1 Cout additionneur
o Cin  SW Cin=0
1 bit
o S  LEDG0
o Cout LEDR0  Cout
S
Additionneur 4 bits

 Re-exploiter l’additionneur 1 bit pour réaliser un additionneur 4 bits à propagation

simple de retenue. Pour cela créer une autre solution où l’additionneur 4 bits et le
composant principal. L’additionneur 1 bit doit être dans un ficher associer à
l’application.
o Instancier l’additionneur 1 bit dans la partie déclarative de l’architecture avec
component
o Associer les ports des composants à l’aide de la clause port map
 Afin de faciliter l’utilisation du circuit, associer aux entrées et aux sorties les composant
suivants :
o A[0..3]  SW0 .. SW3
o B[0..3]  SW5 .. SW8
o Cin  SW9
o S[0..3]  LEDR0.. LEDR3
o Cout  LEDG0
Xn-1 Yn-1 X1 Y1 X Y0

additionneur cn-1 c2 additionneur c1 additionneur

Cout 1 bit ••••••••• 1 bit 1 bit Cin=0

Sn-1 S1 S0

A. Jilbab Page 20
 FPGA EEIN

Compteurs
L’objectif est concevoir et de manipuler un compteur/décompteur synchrone. Nous équiperons
ce compteur successivement d’une Reset synchrone/asynchrone, d’un UP/Down, et d’une
entrée de pré-chargement. Ce compteur nous servira pour la réalisation d’un effet à base de
LED de type K 2000.

Diviseur de fréquences

Le circuit DE2 étant équipé uniquement de deux horloges à 50MHz et 27MHz, il faudra dans
un premier temps élaborer une horloge présentant des fréquences plus faibles (1~10Hz).

 Implémenter ce diviseur de fréquences sous forme d’un compteur :

o Entrée à 50 MHz <= CLOCK_50
o Sortie entre 1~10Hz
 Synchroniser l’horloge basse fréquence sur le front montant de l’horloge à 50 MHz,
utilisez pour la procédure : WAIT UNTIL pour détecter le front mentant de l’horloge

Compteur simple

 Réaliser maintenant un compteur BCD 4 bits, synchronisez le sur le front descendant

de l’horloge basse fréquence.
 Réexploiter le package (convertisseur BCD -> 7 segments) réalisé lors de la dernière
séance pour afficher la sortie du compteur sur les afficheurs HEX4 et HEX5.

Compteur avec une entrée de remise à zéro

 Faire évoluer le circuit précédent pour obtenir un compteur présentant une entrée de
remise à zéro asynchrone « RAZ ».
 Lier cette « RAZ » l’entrée physique : SW17
 Synchroniser ensuite la « RAZ » sur le front montant de l’horloge.

Compteur / Décompteur à entrée de pré-chargement

 Intégrer au compteur précédant une entrée permettant basculer entre un

comptage/décomptage.
 Lier cette entrée au SW16
 Intégrer au compteur un module de pré-chargement
o Une entrée pour spécifier ce mode « LOAD » : SW15
o Quatre entrées correspondantes aux données à charger « DATA » : SW0~SW3

Effet K 2000

 Dans un premier temps réaliser un package permettant de traduire les sorties du

compteur pour s’afficher sur les LED en chenille : LEDR0~LEDR15
 Apporter les modifications nécessaires pour obtenir l’effet visuel désiré : K 2000

A. Jilbab Page 21
 FPGA EEIN

Registre à Décalage
Il s’agit d’implémenter un registre à décalage de différentes façons. Dans un premier temps
vous effectuerez une implémentation directe, ensuite vous réaliserez le même composant en
combinant des multiplexeurs avec des bascules D.

Implémentation I d’un registre à décalage

 Implémenter le circuit qui réalise la fonction du registre à décalage synchrone (front

montant) suivant :
IL I3 I2 I1 I0 IR

S0
S1
REG_DEC

CLOCKK

Q3 Q2 Q1 Q0
 4 entrées/4 sorties
 1 entrée horloge
 2 entrées de sélection qui permettent de choisir le mode :

Fonction réalisée après le top

S0 S1 Opération
horloge

0 0 Q[3..0] <=Q[3..0] Pas de changement

0 0 Q[3..0] <=I[3..0] Chargement parallèle

1 0 Q[3..1]<=Q[2..0], Q[0]<=IR Décalage à gauche avec

IR

1 1 Q[3]<=IL, Q[2..0]<=Q[3..1] Décalage à droite avec IL

o Utiliser l’horloge élaborée dans le TD 3 pour alimenter le circuit.

o Afficher les sorties Q0..Q3 sur les DEL LEDR[0..3].

D Q
Implémentation II d’un registre à décalage

 Dans un premier temps implémenter une bascule D réagissant au front

montant d’une horloge CLOCK Q

A. Jilbab Page 22
 FPGA EEIN
o Vérifier la validité fonctionnelle et temporelle du
circuit par simulation.

 Implémenter un multiplexeur 4 entrées/1 sortie/2 entrées Q0 Q1 Q2 Q3

de sélection. S1 1
o Vérifier la validité fonctionnelle et temporelle du
circuit par simulation. S0 0
D

 Sur la base des deux composants réalisés précédemment, implémentez le registre à

décalage suivant :
IL Q2 I3 Q3 Q3 Q1 I2 Q2 Q2 Q0 I1 Q1 Q1 IR I0 Q0

S1 S1 S1 S1
U1 U2 U3 U4
S0 S0 S0 S0

U5 U6 U7 U8
D Q D Q D Q D Q

Q Q Q Q

CLOCK

Q2 Q1 Q1

Les entrées S0 & S1 des multiplexeurs permettront de sélectionner la fonction à réaliser de la

façon suivante :

S0 S1 Entrées du registre Opération

0 0 Q3 Q2 Q1 Q0 Pas de changement

0 0 I3 I2 I1 I0 Chargement parallèle

1 0 Q2 Q1 Q0 IR Décalage à gauche avec IR

1 1 IL Q3 Q2 Q1 Décalage à droite avec IL

 Réaliser un affichage à la sortie du registre à décalage à l’aide des DELs LEDR[0..3].

A. Jilbab Page 23
 FPGA EEIN

VI. Les machines à états

Les automates de Moore
L’objectif est l’intégration sur un circuit FPGA, en VHDL, d’automates. Nous commencerons
par l’implémentation d’un automate de Moore à deux états sans entrées, puis progressivement,
on mettra en place un automate à plusieurs états et présentant plusieurs entrées.

Automate de Moore à deux états

 Implémenter l’automate à deux états suivant :

Marche Arrêt

o L’automate ne présent ni entrées ni sorties (oscillateur).

o Les transitions de l’automate doivent être synchrones (front montant).

 Rajouter une entrée de remise à zéro (sur arrêt) asynchrone.

 Rajouter une entrée « ma » pour conditionner le passage entre les deux états.

ma=1
Marche Arrêt RAZ = 1
ma=0

Automate de Moore à quatre états

 Implémenter l’automate de Moore à : quatre états (S1, S2, S3, S4), trois entrées (X1,X2,
RAS), deux sorties (S1, S2) suivants :
E1
S1 =0
X1 = 1 X1 = 0
S2 = 1

E2 RAZ = 1 X2 = 1 E3
S1 = 1 S1 = 0

S2 = 0 S2 = 0
X1 = 1 X1 = 0
E4
S1 = 1

S2 = 1

A. Jilbab Page 24