Telechargé par Ossama Mafhoum

Cours et TP FPGA

publicité
Institut Universitaire de Technologie de CRETEIL-VITRY
Département de Génie Électrique et Informatique Industrielle
MC-ENSL1 - Composants programmables complexes
COURS / TP
FPGA
Année universitaire 2013-2014
J. VILLEMEJANE - julien.villemejane@u-pec.fr
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
Consignes
Faire valider le code par l’enseignant avant la programmation de la carte
Faire valider chacun des exercices par l’enseignant
Il vous est conseillé de faire un compte-rendu de chacun des TP
Répartition des séances
Séance 1 (cours/TP) : Introduction (TP0 et TP1)
Séance 2 (cours/TP) : Structuration-Simulation (TP2)
Séance 3 (TP) : Structuration-Simulation (TP2)
Séances 4 et 5 : Affichage multiplexé (TP3)
Séance 6 : TP Test 1
Séances 7 à 9 : Projet
Séance 10 : TP Test 2
Table des matières
TP0 - Systèmes logiques programmables
4
TP1 - Développement d’un système numérique
10
TP2 - Structuration et simulation
16
TP3 - Affichage multiplexé
20
TP4 - Mise en oeuvre d’un microcontroleur simple
23
–3–
GEII - MC-ENSL1
TP 0
Systèmes logiques programmables
Objectifs
Découvrir l’architecture des FPGA.
Découvrir la carte d’étude BASYS de Digilent.
Dans le domaine des systèmes numériques, il existe deux grandes sortes de composants :
les processeurs (et dérivés : microcontroleurs, DSP...) qui font du traitement séquentiel
les composants programmables qui font du traitement parallèle
Il existe trois grandes catégories de systèmes logiques programmables :
les CPLD (Complex Programmable Logic Device)
les FPGA (Field Programmable Gate Array)
les ASIC (Application Specific Integrated Circuit)
Les CPLD sont de conception plus anciennes et ont généralement des capacités moindres que les FPGA. Cependant,
ils sont encore largement utilisés dans des systèmes logiques (combinatoire ou séquentiels).
Dans les deux cas, ce sont des réseaux logiques programmables composés de nombreuses cellules logiques élémentaires librement assemblables. Nous allons ici étudier plus en détails les FPGA, les CPLD ayant déjà été abordés en
première année (module ENSL1).
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
1. Les FPGA
Ces systèmes programmables sont initialement destinés au prototypage de systèmes numériques complexes. Ils
sont une bonne alternative aux circuits spécifiques, les ASIC (Application Specific Integrated Circuit), pour des petites ou
moyennes séries.
Il existe plusieurs grands fabricants : ALTERA, ACTEL (composants spécialisés) et XILINX. Pour les TP, nous
utiliserons des FPGA de chez Xilinx.
1.1. Implantation
Chaque fabricant propose aussi des composants de taille variable : de 100.000 à 10.000.000 portes logiques. Par
comparaison, les portes standards commerciales possèdent entre 2 et 8 portes logiques pour une surface de silicium
quasiment identique.
Quelque soit la technologie utilisée, aucune porte logique n’est réellement implantée. Il s’agit en fait de blocs
logiques programmables, mais très versatiles (RAM), et d’une mer de connexions programmables. Chez Xilinx, ces
blocs logiques sont appelés CLB (Common Logic Blocks).
1.2. Avantages et inconvénients
Très haute densité
Grande vitesse (100 MHz à quelques GHz)
Très grand nombre d’entrées/sorties (boîtiers BGA)
Prix élevé (mais en baisse)
Alimentation difficile (plusieurs tensions, courants élevés, connexions multiples)
Volatiles (cellules RAM)
Circuits imprimés (PCB - Printed Circuit Board) multicouches
2. Structure d’un FPGA - Xilinx
L’architecture, retenue par Xilinx, se présente sous forme de deux couches : une couche circuit configurable et un
réseau de mémoire SRAM. La structure d’un FPGA est donnée dans la figure suivante. L’échelle est loin d’être réelle,
les fonctions logiques n’occupant qu’environ 5% du circuit.
Figure 1 – Structure d’un FPGA
Les FPGA sont un rassemblement et une combinaison de différents blocs : d’entrées/sorties (IOB - Input Output
Blocks), de routage (PSM - Programmable Switch Matrix), de logique programmable (CLB - Configurable Logic
–5–
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
Blocks) et d’autres blocs plus spécifiques.
2.1. Spartan XL 3E
Les Spartan 3E, que nous allons utiliser par la suite, sont basés sur ce type de structure. La figure suivante détaille leur
architecture. Le tableau rassemble les différentes caractéristiques de cette famille de FPGA.
Figure 2 – Structure et caractéristiques des Spartan 3 - Xilinx
Les CLB (voir figure 3) sont décomposés en 2 ou 4 SLICE (appellation de Xilinx). Ces SLICE sont eux-mêmes
décomposés en 2 LUT (Look-Up Table) et 2 bascules D.
Figure 3 – Bloc logique configurable - Xilinx Spartan 3
–6–
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
2.2. LUT et bascule
Les fonctions combinatoires sont implantées sur des mémoires SRAM (LUT = Look-Up Table). La table de vérité
est alors chargée dans ces LUT. La figure 4 montre le cas de LUT à 2 entrées. En général, les FPGA sont équipés de LUT
à 4 ou 6 entrées.
Figure 4 – LUT - Xilinx Spartan 3
Les éléments séquentiels (synchrones sur front ou niveau) sont implantés sur des bascules (D le plus fréquemment).
3. Carte d’étude BASYS2 - Digilent
L’ensemble des exemples et applications qui seront demandés dans ces TP seront réalisés sur une carte de développement BASYS2, proposé par la société Digilent. Ces cartes sont basées sur le FPGA Spartan 3E-250 de Xilinx.
Figure 5 – Carte BASYS2 - Digilent
3.1. Entrées-sorties logiques
Les entrées logiques sont essentiellement réalisées par 8 interrupteurs dénommés SW0 à SW7 et par 4 boutonspoussoirs dénommés BTN0 à BTN3.
Les sorties pourront être visualisées sur 8 diodes électroluminescentes (LD0 à LD7) ou bien 4 afficheurs 7 segments
multiplexés (DISP1).
–7–
COURS / TP
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
élément
SW7
SW6
SW5
SW4
SW3
SW2
SW1
SW0
broche
N3
E2
F3
G3
B4
K3
L3
P11
élément
LD7
LD6
LD5
LD4
LD3
LD2
LD1
LD0
broche
G1
P4
N4
N5
P6
P7
M11
M5
élément
BTN3
BTN2
BTN1
BTN0
MCLK
broche
A7
M4
C11
G12
B8
HS
VS
J14
K13
élément
RED0
RED1
RED2
BLU1
BLU2
GRN0
GRN1
GRN2
broche
C14
D13
F13
H13
J13
F14
G13
G14
3.2. Horloges
Il y a trois horloges de caractéristiques différentes produites par un circuit spécial : 25, 50 et 100 MHz.
Ces trois signaux sont connectés à la même broche spécifique du FPGA.
3.3. Afficheurs 7 segments multiplexés
Le multiplexage de l’affichage permet de limiter le nombre de connexions
pour ces 4 afficheurs. Mais son fonctionnement exige la mise en œuvre
de composants séquentiels.
Pour activer un segment (cathode), on doit placer un ’0’ (zéro) sur
la sortie correspondant au segment seg. Pour activer un afficheur, il faut
également placer un ’0’ sur la sortie an désirée, (en raison de la présence
d’un transistor amplificateur inverseur).
a...g, dp = cathodes des segments et du point décimal de tous les
afficheurs ; an = commandes des anodes communes des afficheurs.
élément
broche
type
an(0)
an(1)
an(2)
an(3)
J12
F12
K14
M13
commande anode gauche
commande anode
commande anode
commande anode droite
élément
broche
type
A, seg(6)
B, seg(5)
C, seg(4)
D, seg(3)
E, seg(2)
F, seg(1)
G, seg(0)
DP
L14
H12
N14
N11
P12
L13
M12
N13
sortie
sortie
sortie
sortie
sortie
sortie
sortie
sortie
3.4. Description en VHDL
Pour décrire les différents systèmes numériques, nous utiliserons le logiciel de chez Xilinx : ISE Webpack (version
10.5). Cette version est disponible gratuitement, moyennant une inscription, sur le site de xilinx (www.xilinx.com).
Ce logiciel permet de décrire des systèmes en VHDL ou Verilog, de les tester (de manière fonctionnelle ou temporelle)
et de créer un fichier binaire compatible avec la cible (ici un FPGA Spartan 3E). Les étapes de développement seront
décrites par la suite.
3.5. Contraintes
Il ne faut pas oublier d’assigner les entrées/sorties de votre système aux broches réelles du système. Le système final
étant déjà câblé, ces contraintes sont déjà prédéfinies (voir tableaux précédent - 7 segments - et suivant).
3.6. Implémentation du programme
Une fois que toutes les étapes de «compilation» sont réussies, un fichier binaire *.bit est généré et peut alors être
implanté dans le FPGA.
Pour cela, il est nécessaire de relier la carte sur un des ports USB de l’ordinateur et d’allumer la carte d’étude (interrupteur le plus à gauche - SW8).
–8–
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
L’utilitaire Adept (Digilent) sera alors utiliser pour transférer le fichier binaire vers le FPGA.
–9–
COURS / TP
GEII - MC-ENSL1
TP 1
Développement d’un système numérique
Objectifs
Développer des systèmes numériques programmables simples (multiplexeur, compteur...).
Simuler un système numérique.
Il existe 2 langages de description pour les FPGA :
VHDL : Very High Speed integrated circuit Hardware Description Language ;
Verilog.
Nous nous intéresserons par la suite au VHDL, qui est un langage de description normalisé (IEEE) et quasi-universel
pour décrire des circuits intégrés.
1. Structure d’un projet
Un projet VHDL est très souvent décomposé en sous-structures,
appelées modules ou composants. Comme on pourrait le faire sur un
circuit imprimé, il s’agit d’instancier différents composants et de les
relier entre eux par des fils (signaux en VHDL) pour réaliser le système
complet.
Chacun de ces modules est alors décrit dans un fichier source indépendant. Chacun de ces fichiers sources peut alors être testé indépendamment en lui associant un fichier de simulation (ou testbench).
Enfin des fichiers de contraintes permettent de faire le lien entre
la description logicielle et la structure matérielle de la cible et de son
environnement (position des entrées, des sorties...).
Figure 6 – Structure d’un projet
2. Phases de développement
L’écriture des différents modules (ou composants) est la première chose à réaliser. Ceux-ci peuvent être décrits et
testés séparément. Nous verrons par la suite comment décrire un composant.
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
Ensuite, il est possible (et fortement conseillé) de vérifier la syntaxe de la description, en faisant appel à la fonction
"Check Syntax" dans la partie "Synthetize XST". Cette étape est assez rapide et ne nécessite pas de connaître la cible,
contrairement à l’étape d’après.
Viens ensuite la phase de synthèse ("Synthetize XST") puis de placement et de routage ("Implement Design"). Ces
étapes nécessitent la connaissance, d’une part, de la cible (FPGA ou CPLD) et, d’autre part, de l’environnement du circuit
(entrées/sorties associées aux autres composants de la maquette). Il est donc nécessaire, avant de réaliser ces étapes-là,
de faire l’assignation des broches du composant avec la description fournie. Pour cela, vous pouvez vous aider de la
fonction "Assign Package Pins" dans la partie "User Constraints" et de la documentation de la maquette fournie en début
de ce document.
Il est aussi possible à ce stade de lancer différentes simulations :
fonctionnelle : permettant de savoir si le fonctionnement du système est celui décrit ;
post-synthèse : permettant, après synthèse, de vérifier à nouveau le fonctionnement du système ;
temporelle : permettant, après l’étape de routage, de valider les contraintes temporelles associées au placement des
"composants".
Ces différentes phases doivent être répétées pour l’ensemble des modules composant l’application. La dernière étape
consiste à produire le fichier de programmation ("Generate Programming File") et à le transférer dans la mémoire du
FPGA.
3. Structure d’un module VHDL
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.
3.1. Déclaration des ressources externes
Cette phase est réalisée automatiquement pour les bibliothèques courantes. On retrouve en en-tête du fichier source
*.vhd les instructions suivantes :
1
2
3
4
l i b r a r y IEEE ;
u s e IEEE . STD_LOGIC_1164 . ALL;
u s e IEEE . STD_LOGIC_ARITH . ALL;
u s e IEEE . STD_LOGIC_UNSIGNED . ALL;
– 11 –
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
3.2. Entité
L’entité permet de spécifier les différents ports d’entrées/sorties du système. Pour
chacun d’entre eux, il est indispensable de donner sa direction :
in entrée simple
out sortie simple
buffer sortie rétroactive
inout entrée-sortie bidirectionnelle (conflits possibles)
et son type (voir section suivante).
1
2
3
4
5
6
entity cours is
port (
a, b :
i n STD_LOGIC ;
s :
o u t STD_LOGIC
);
end c o u r s ;
−− c o m m e n t a i r e
3.3. Architecture
Une architecture est reliée à une entité et permet de décrire le fonctionnement du système. Cette description peut
être de deux types :
description comportementale : le comportement du système est décrit (description la plus couramment utilisée en
VHDL) ;
description structurelle : la structure meme du système est décrite à base de portes logiques, bascules... (description
réservée à des fonctions simples ou pré-calculées).
1 architecture Behavorial of cours i s
2 −− d e c l a r a t i o n d e s s i g n a u x
3 begin
4
processus1 ;
5
processus2 ;
6
...
7 end B e h a v o r i a l ;
4. Objets et types en VHDL
4.1. Objets
signal objet physique, associé à des évènements
variable intermédiaire de calcul, non physique
constant
4.2. Types
Types de base : bit, bit_vector, integer, boolean
Types IEEE : std_logic, std_logic_vector, signed, unsigned
Types définis par l’utilisateur :
- type énuméré, exemple : type jour is (lu, ma, me, je, ve, sa, di); (souvent utilisé dans les machines à état)
- sous-type : subtype octet is bit_vector(0 to 7);
4.3. Notations
bit : ’0’ ou ’1’ ; bit_vector : "0100" ; ASCII : "Texte" ; Décimal : 423 ; Hexadécimal : x"1A"
4.4. Opérateurs en VHDL
– 12 –
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
LOGIQUES : and, nand, or, nor, xor, xnor, not
DÉCALAGE : sll, slr, sla, sra, rol, ror
RELATIONNELS : =, /=, <, >, <=, >=
ARITHMÉTIQUES : +, -, *, /, MOD
CONCATENATION : &
AFFECTATION : <=
5. Instructions en VHDL
5.1. Hors processus
Ces instructions décrivent le plus souvent des éléments combinatoires (concurrentes).
5.1.1
Affectation conditionnelle
1
2
3
4
5.1.2
x <=
a when cond1 e l s e
b when cond2 e l s e
...
z;
Affectation sélective
1
2
3
4
5
5.1.3
with expr s e l e c t
x <= a when v a l 1 ,
b when v a l 2 ,
...
z when o t h e r s ;
For... generate
1
2
3
f o r i i n MIN t o MAX g e n e r a t e
i n s t r u c t i o n s de d e s c r i p t i o n ;
end g e n e r a t e ;
5.2. Dans un processus
L’exécution des instructions s’effectue dans un ordre séquentiel (ordre d’écriture). Le processus est activé lorsqu’un
des éléments de la liste de sensibilité est modifié.
La mise à jour des objets s’effectue simultanément à la fin du processus.
5.2.1
Syntaxe
Label : process(liste des signaux de sensibilité)
Nom des objets internes : types ; – si nécessaire
begin
...
end process;
– 13 –
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
5.2.2
Test : SI
1
2
3
4
5
5.2.3
i f x=" 00 " t h e n
y <= ’ 0 ’ ;
e l s i f x=" 01 " t h e n
y <= ’ 1 ’ ;
end i f ;
Test : CAS
1
2
3
4
5
5.2.4
case x i s
when " 00 " => y <= " 00 " ;
when " 01 " => y <= " 10 " ;
when o t h e r s => y <= " 11 " ;
end c a s e ;
Blocs répétitifs
1
2
3
for i in 0 to 5 loop
instructions ;
end l o o p ;
1
2
3
while i < 5 loop
instructions ;
end l o o p ;
5.2.5
Temporisation
1
2
w a i t u n t i l CLK’ e v e n t and CLK= ’ 1 ’ ;
instructions ;
6. Tournures fréquentes en VHDL
6.1. Détection d’un front
1
2
i f c l k ’ e v e n t and c l k = ’1 ’ t h e n . . .
i f c l k ’ e v e n t and c l k = ’0 ’ t h e n . . .
; −− f r o n t m o n t a n t
; −− f r o n t d e s c e n d a n t
6.2. Remplissage d’un vecteur (bit_vector)
1
2
x <= ( o t h e r s => ’ 0 ’ ) ;
x <= ( o t h e r s => ’ 1 ’ ) ;
−− t o u s l e s b i t s a 0
−− t o u s l e s b i t s a 1
– 14 –
COURS / TP
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
7. Prise en main de la maquette
On se propose ici de reprendre en main le logiciel Xilinx ISE Webpack. Pour cela, ils vous est demandé de réaliser
les systèmes suivants.
EXERCICE 1
Décrire un système logique en VHDL dont le fonctionnement est donné par l’équation :
s = a + a + b.
a et b seront des interrupteurs et s une LED.
EXERCICE 2
1. Décrire un multiplexeur 4 vers 1 avec une entrée de validation.
2. Décrire un démultiplexeur 1 vers 4.
Les entrées seront réalisées par des interrupteurs et les sorties par des LEDs.
EXERCICE 3
Réaliser un compteur 4 bits.
L’horloge sera réalisée à l’aide d’un bouton poussoir et les sorties seront visualisées sur des
LEDs.
Attention : pour les versions supérieures à 10.1 de Xilinx ISE, afin de pouvoir générer le fichier de programmation correctement, vous devrez ajouter la ligne : NET "clk" CLOCK_DEDICATED_ROUTE = FALSE; dans le fichier de
contraintes (*.ucf).
– 15 –
GEII - MC-ENSL1
TP 2
Structuration et simulation
Objectifs
Structurer un système en bloc fonctionnel (instanciation de composants).
Simuler des systèmes numériques simples avec Xilinx ISE.
1. Structuration et instanciation de composants
Afin de simplifier la description d’un système numérique, les concepteurs découpent leurs applications en sous-blocs
fonctionnels décrivant une partie de cette dernière. En VHDL, ces sous-blocs sont appelés modules ou composants.
Il est alors plus simple de décrire et de tester chacun de ces modules séparément pour pouvoir les regrouper par la suite
dans un seul système. A l’image d’un catalogue de composants et d’un circuit imprimé, il sera alors possible d’instancier
ces modules et de les relier entre eux par des signaux.
1.1. Déclaration d’un composant
La déclaration préalable d’un composant s’effectue soit dans un paquetage, soit dans la zone de déclaration d’une
architecture.
1
2
3
4
5
component n o m _ e n t i t e
g e n e r i c ( param1 : i n t e g e r := 3 ) ;
port ( e n t r e e : in b i t ;
s o r t i e : out s t d _ l o g i c ) ;
end component ;
1.2. Structuration du système
Chacun des modules doit être décrit dans un fichier *.vhd séparé, portant le nom de l’entité qu’il décrit. Il y aura
donc autant de fichiers *.vhd que de types de composants.
EXERCICE 0
On souhaite réaliser un additionneur de 3 nombres codés sur 4 bits : a, b et c ; à l’aide
d’additionneurs à 2 entrées (4 bits).
1.2.1
Description du composant additionneur
Fichier additionneur.vhd
1 l i b r a r y IEEE ;
2 u s e IEEE . STD_LOGIC_1164 . ALL;
3
4 entity additionneur is
5
port (
a , b : i n STD_LOGIC_VECTOR ( 3 DOWNTO 0 ) ;
6
s : o u t STD_LOGIC_VECTOR ( 3 DOWNTO 0 )
7
);
8 end a d d i t i o n n e u r ;
9
10 a r c h i t e c t u r e s i m p l e o f a d d i t i o n n e u r i s
11 −− d e c l a r a t i o n d e s s i g n a u x s i b e s o i n
12 b e g i n
13
−− p r o c e s s u s a e c r i r e
14
s <= a + b ;
15 end s i m p l e ;
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
1.2.2
COURS / TP
Composants déclarés dans la zone de déclaration de l’architecture
Fichier system.vhd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
l i b r a r y IEEE ;
u s e IEEE . STD_LOGIC_1164 . ALL;
e n t i t y system i s
Port (
a _ s y s , b _ s y s , c _ s y s : i n STD_LOGIC_VECTOR ( 3 DOWNTO 0 ) ;
s _ s y s : o u t STD_LOGIC_VECTOR ( 3 DOWNTO 0 )
);
end s y s t e m ;
ar chi tect ure simple of system i s
component a d d i t i o n n e u r
port (
a , b : i n STD_LOGIC_VECTOR ( 3 DOWNTO 0 ) ;
s : o u t STD_LOGIC_VECTOR ( 3 DOWNTO 0 )
);
end component ;
s i g n a l s _ s i g : STD_LOGIC_VECTOR ( 3 DOWNTO 0 ) ;
begin
add1 : a d d i t i o n n e u r
p o r t map ( a => a _ s y s , b => b _ s y s , s => s _ s i g ) ;
add2 : a d d i t i o n n e u r
p o r t map ( a => c _ s y s , b => s _ s i g , s => s _ s y s ) ;
end s i m p l e ;
1.3. Exercices
EXERCICE 1
1. Réalisez et testez un multiplexeur de 4 lignes (4 interrupteurs) vers 1 ligne, que vous
décrirez dans un fichier mux.vhd.
2. Réalisez et testez un démultiplexeur 1 ligne vers 4 lignes, que vous décrirez dans une
fichier demux.vhd.
3. Assemblez ces deux fichiers dans system.vhd afin de simuler une ligne de transmission série ayant 4 interlocuteurs possibles de chaque coté.
La sélection des voies du multiplexeur (AS) et la sélection de la destination en sortie du
démultiplexeur (AD) se feront par 2 x 2 interrupteurs.
Les données seront réalisées par 4 interrupteurs et la visualisation des sorties par 4 LEDs.
On réalise ainsi une fonction de «routage» de données : sélection d’un émetteur et d’un récepteur parmi des nombreux
éléments, en utilisant un medium unique de communication (virtuel ici).
– 17 –
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
EXERCICE 2
La luminosité d’un éclairage (dans notre cas, une LED) peut être réglée par l’application
d’un signal rectangulaire périodique de fréquence assez élevée et de rapport cyclique non
constant. On parle alors de gradateur.
Le rapport cyclique d’un signal rectangulaire périodique est défini comme le rapport entre
le temps pendant lequel le signal est à l’état haut et la période. On exprime souvent ce
rapport en pourcentage. Ainsi :
la LED est éteinte pour une rapport cyclique de 0% ;
la luminosité est maximale pour une rapport cyclique de 100% ;
la luminosité est environ à moitié pour un rapport cyclique de 50%.
Cette application peut être simplement réalisée à l’aide d’un compteur à 8 bits (synchrone)
et d’un comparateur arithmétique à 8 bits. Les interrupteurs déterminent le rapport cyclique.
L’horloge à choisir pour le compteur est CLK1 (50 Mhz).
1. Donner la structure que devra avoir cette application.
2. Décrire en VHDL chacun des modules de cette application.
3. Réaliser le fichier source permettant de décrire ce gradateur de LED en instanciant
les composants nécessaires.
2. Simulation
Il existe 2 niveaux de simulation :
comportementale (behavorial simulation) ;
physique (post-route simulation).
Dans la version allégée de Xilinx ISE WebPack, seule la simulation comportementale est disponible.
2.1. Simulation comportementale
Pour tester un module VHDL, il faut lui associer un module générateur de signaux (non synthétisable) : le testbench.
Le testbench est un module VHDL spécial (disponible dans la liste des nouveaux modules lors de l’ajout de fichier source). Il inclut le module à tester comme un composant et lui associe des signaux. L’écriture d’un testbench est
automatisée avec Xilinx ISE.
Il reste ensuite à écrire un scénario de test animant les signaux d’entrée du module en test. On utilisera alors la même
syntaxe qu’un module classique mais avec des instructions spécifiques.
2.1.1
Instructions spéciales
La gestion du temps peut se faire hors processus :
1
2
c l k <= n o t c l k a f t e r 1000 u s ;
−− h o r l o g e a 500 Hz
ou dans un processus :
1
2
3
4
5
6
7
horloge_500 : process
begin
c l k <= ’ 0 ’ ;
w a i t f o r 500 u s ;
c l k <= ’ 1 ’ ;
w a i t f o r 500 u s ;
end p r o c e s s ;
L’instruction wait ; provoque l’arret de la simulation.
– 18 –
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
2.1.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
2.1.3
Exemple
entity porteab_tb is
end p o r t e a b _ t b ;
architecture behavior of porteab_tb i s
component p o r t e a b
port ( a , b : in s t d _ l o g i c ;
s : out s t d _ l o g i c ) ;
end component ;
−− i n p u t s
s i g n a l a , b : s t d _ l o g i c := ’ 0 ’ ;
−− o u t p u t s
signal s : std_logic ;
begin
−− i n s t a n c i a t i o n
u u t : p o r t e a b p o r t map ( a => a , b => b , s => s ) ;
−− s c e n a r i o
stim_proc :
begin
wait for
wait for
wait for
wait for
process
50
50
50
50
ns ;
ns ;
ns ;
ns ;
a
a
a
a
<=
<=
<=
<=
’0 ’;
’1 ’;
’0 ’;
’1 ’;
b
b
b
b
<=
<=
<=
<=
’0 ’;
’0 ’;
’1 ’;
’1 ’;
wait ;
end p r o c e s s ;
end b e h a v i o r ;
Exercices
EXERCICE 3
1. Associer ce fichier de test à la description de l’exercice 1 du TP1 (fonction s =
a + a + b).
2. Lancer la simulation et vérifier le bon fonctionnement du système.
EXERCICE 4
1. Décrire un compteur 4 bits avec une remise à zéro asynchrone.
2. Réaliser le fichier de test de ce module VHDL (en pensant à remettre à zéro les sorties
dès le début de la simulation).
3. Lancer la simulation et vérifier le bon fonctionnement du système.
Lancer la simulation.
– 19 –
COURS / TP
GEII - MC-ENSL1
TP 3
Affichage multiplexé
Objectifs
Réaliser un module d’affichage hexadécimal sur 4 afficheurs 7 segments fonctionnant en mode multiplexé.
1. Principe d’un affichage multiplexé
Dans un système d’affichage, le multiplexage est un procédé qui consiste à utiliser plusieurs voyants ou plusieurs
afficheurs et à ne pas tous les allumer à la fois, en vue d’économiser de l’énergie et de limiter le nombre de fils de câblage.
Par exemple, l’affichage de votre radio réveil numérique, de votre machine à laver ou de votre four micro-onde est fort
probablement multiplexé.
Les données à envoyer sur les afficheurs transitent par un même bus (7 fils dans le cas d’un afficheur 7 segments)
pour l’ensemble de ces afficheurs. Ainsi le chiffre à afficher est envoyé sur tous les afficheurs en même temps. Sans une
gestion particulière de ces afficheurs, il n’est pas possible d’écrire des nombres.
C’est pourquoi, en parallèle ce ces entrées de données, il existe une entrée de validation pour chacun des afficheurs.
Ces entrées sont souvent commandés via des transistors pour permettre un gain de courant. Le schéma ci-dessous donne
le câblage d’un tel système (3 afficheurs 7 segments dans ce cas-là).
2. Etude du système
Afin de développer ce module de gestion d’affichage multiplexé de manière la plus simple possible, nous allons
découper cette application en plusieurs blocs fonctionnels que nous allons par la suite décrire en VHDL séparément :
un décodeur décimal → 7 segments ;
un diviseur de fréquence ;
un compteur pour le balayage des afficheurs ;
un multiplexeur 4 vers 1 (4 x 4 bits d’entrée).
Pour pouvoir tester ce système, des registres de stockage d’entrée seront ajoutés.
EXERCICE 1
1. Faire le schéma synoptique de ce système en faisant ressortir les différentes entrées
et sorties, ainsi que les signaux intermédiaires.
2. Rappeler le fonctionnement d’un registre. Combien de bascules seront nécessaires
pour réaliser l’étage de stockage en entrée ?
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
3. Module 1 - Décodeur BCD / 7 segments
On souhaite réaliser un décodeur décimal à 7 segments utilisant un seul afficheur (une des sorties an devra être mise
à ’0’).
EXERCICE 2
1. Créer un fichier source VHDL nommé BCD7seg.vhd.
2. Décrire ce système en utilisant uniquement des affectations conditionnelles ou sélectives (pas de process).
Les données à convertir sont fournies par 4 interrupteurs.
4. Module 2 - Diviseur de fréquence
La fréquence de balayage des 4 afficheurs sera fixée à 100 Hz. Il sera donc nécessaire de disposer d’une horloge à
400 Hz pour le balayage. Le diviseur de fréquence à concevoir sera actionné par l’horloge CLK1 de la carte (50 MHz).
EXERCICE 3
1. Créer un fichier source VHDL nommé prediv.vhd.
2. Décrire ce système en VHDL, pour passer d’une fréquence de 50 MHz à 400 Hz.
5. Module 3 - Compteur pour le balayage
Afin de pouvoir séquentiellement sélectionner un des afficheurs, nous allons à présent nous intéresser à un compteur
synchrone.
EXERCICE 4
1. Combien d’états devra comporter ce compteur ? Combien de bascules seront alors
nécessaires ?
2. Créer un fichier source VHDL nommé cpt.vhd.
3. Décrire ce système en VHDL.
6. Module 4 - Multiplexeur d’entrée
On souhaite pouvoir affecter à l’entrée du décodeur BCD/7segments une des 4 données présentes en entrée, afin
qu’elles soient séquentiellement affichées.
EXERCICE 5
1. Quelle est la taille du mot binaire présent à chaque entrée ? Quelle est la taille du mot
de sortie ?
2. Créer un fichier source VHDL nommé muxBCD.vhd.
3. Décrire ce système en VHDL.
7. Module 5 - Décodeur 2 vers 4
On souhaite réaliser un décodeur 2 vers 4 permettant à partir du module "compteur" de sélectionner un des 4 afficheurs
7 segments. Ces afficheurs sont actifs à l’état bas.
– 21 –
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
EXERCICE 6
1. Créer un fichier source VHDL nommé dec2v4.vhd.
2. Décrire ce système en utilisant uniquement des affectations conditionnelles ou sélectives (pas de process).
Les données à convertir sont fournies par 4 interrupteurs.
8. Afficheur complet
En regroupant l’ensemble des éléments précédents, il est possible de réaliser un afficheur multiplexé complet.
EXERCICE 7
1. Créer un fichier source VHDL nommé aff7seg.vhd.
2. Instancier les composants nécessaires au bon fonctionnement du système dans ce
fichier source.
3. Réaliser alors un afficheur multiplexé présentant un message constant (configuré dans
le source, par exemple "1984").
9. Amélioration
Pour les exercices suivants, une source d’entrée sur 16 bits (4x4) et facilement réglable est nécessaire.
EXERCICE 8
1. Créer un fichier source VHDL nommé regBCD.vhd.
2. Décrire un registre parallèle à 4 bits ayant une entrée de validation.
3. Ajouter à la description contenue dans aff7seg.vhd la possibilité d’avoir 4 registres
en entrée, en instanciant le composant précédemment réalisé.
4. Tester alors l’afficheur complet.
Les 4 entrées de chacun des registres seront reliées à 4 interrupteurs. Les entrées de validation de ces registres seront
reliées aux 4 boutons-poussoirs. Lors de l’appui sur l’un deux, la donnée présente sur les 4 interrupteurs sera chargée dans
le registre correspondant et affichée sur l’afficheur correspondant.
Afin de pouvoir générer le fichier de programmation correctement (Xilinx ISE version supérieure à 10.1), vous devrez
ajouter la ligne : NET "clk" CLOCK_DEDICATED_ROUTE = FALSE; dans le fichier de contraintes (*.ucf).
– 22 –
GEII - MC-ENSL1
TP 4
Mise en oeuvre d’un microcontroleur simple
Objectifs
Comprendre et réaliser l’architecture d’un microcontroleur simple en VHDL.
1. Architecture d’un microcontroleur
Les systèmes basés sur des microprocesseurs, tels que les microcontroleurs, possèdent les éléments suivants :
Processeur
Mémoires (Programme - ROM / Données - RAM)
Entrée-Sorties
Afin de relier l’ensemble de ces éléments, différents bus sont indispensables : le bus de données, le bus d’adresses et
le décodeur d’adresse.
Le microprocesseur est composé : d’une Unité Arithmétique et Logique (UAL / ALU), de Registres, d’un Contrôleur (registre d’instruction, décodeur d’instruction et séquenceur) et d’un Compteur programme.
Concernant l’architecture des microcontroleurs et le traitement des instructions, il vous est conseillé de revoir votre
cours de II2.
2. Séquenceur microprogrammé
2.1. Cahier des charges
On souhaite à présent réaliser un microprocesseur à jeu d’instruction très réduit (8 instructions) mais relativement
complet dans sa structure et pouvant traiter des données de 4 bits.
Le microprocesseur sera composé :
d’une unité arithmétique et logique (addition, soustraction, logique booléenne)
d’un registre interne A
d’un contrôleur/séquenceur
d’un compteur programme
2.2. Le jeu d’instruction
Chaque instruction sera codée sur un mot de 8 bits (1 octet).
oc2
instruction
oc1
oc0
3 bits
adr
ad
1 bit
op3
Opérande
op2
op1
4 bits
op0
Deux modes d’adressage seront possibles :
littéral opérande fourni (cste) - ad = 0
direct adresse de l’opérande fourni (adr) - bit ad = 1
Le jeu d’instruction sera le suivant :
Chargement
LDA #cste
LDA $adr
ET logique
ANDA #cste
ANDA $adr
Sauvegarde
STA $adr
Décalage gauche ROLA #cste
000 0 XXXX
000 1 XXXX
100 0 XXXX
100 1 XXXX
001 1 XXXX
101 0 XXXX
Addition
Soustraction
Remise à zéro
Décalage droite
ADDA #cste
ADDA $adr
SUBA #cste
SUBA $adr
RST #cste
RORA #cste
010 0 XXXX
010 1 XXXX
011 0 XXXX
011 1 XXXX
111 0 XXXX
110 0 XXXX
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
3. Etude du système
Une partie du code source de ce micro-controleur est donnée en annexe de ce document.
EXERCICE 1
1. A partir des fichiers sources application.vhd et mon_appli.vhd, faire le schéma
fonctionnel du système.
2. A quoi sert le bloc nommé rom1 ? Ce bloc est-il séquentiel ou combinatoire ?
3. Quelles sont les valeurs stockées dans cette ROM ? A quoi correspondent-elles ?
4. Que manque-t-il à ce microcontroleur pour être complet ?
5. Quelles sont les adresses des périphériques d’entrée et de sortie ?
4. Etude de l’affichage
Le sous-ensemble d’affichage (fichier source afficheur.vhd) n’est normalement pas présent sur un vrai microcontroleur. Dans cet exemple, il n’est là que pour vérifier le bon fonctionnement du système, équivalent à un débugueur.
EXERCICE 2
1. Quel principe est-il utilisé pour afficher les informations sur les différents afficheurs
7 segments ?
2. Quelle est la fréquence de balayage utilisée ?
3. Quelles sont les données qui sont affichées sur les différents afficheurs 7 segments ?
5. Etude du processeur
On se propose à présent d’étudier et de compléter le code fourni correspondant au fonctionnement du processeur.
EXERCICE 3
1. A partir des fichiers sources micropro.vhd et mon_micro.vhd, faire le schéma
fonctionnel du processeur.
2. A quoi servent les différents multiplexeurs et démultiplexeurs ?
5.1. Le compteur programme
Le compteur programme contient l’adresse de la prochaine instruction à exécuter. Il ne doit pas être incrémenté à
chaque coup d’horloge mais seulement lorsque le contrôleur le lui ordonne (une instruction n’étant pas exécutée en un
seul coup d’horloge).
Il doit pouvoir être remis à zéro de façon asynchrone.
EXERCICE 4
1. Combien d’adresses sont-elles disponible dans la mémoire programme ? Combien de
sorties devra alors avoir le compteur programme ?
2. Ajouter la description de ce compteur en VHDL dans le fichier source cpt_pgm.vhd.
3. Comment aurait-on pu faire autrement ce compteur, sans utiliser un signal interne ?
– 24 –
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
COURS / TP
5.2. L’accumulateur / le registre
Selon son instanciation, ce registre doit pouvoir mémoriser une donnée de 4 ou 8 bits présente en entrée lors de la
sélection du registre (entrée WR). Le registre doit être synchrone.
EXERCICE 5
1. Qu’appelle-t-on la généricité d’un code ? A quoi peut-elle servir ? Pour cela, étudier
le code source fourni registre.vhd.
2. Ajouter la description de ce registre générique en VHDL (fichier registre.vhd).
5.3. L’unité arithmétique et logique
Comme son nom l’indique, cet élément réalise des opérations arithmétiques (addition, soustraction...) et logiques (et,
ou...) entre deux données A et B, ici chacune sur 4 bits.
Dans le cadre de notre application, l’ALU doit réaliser 5 opérations différentes. Pour pouvoir les différencier, il est
impératif de les coder, ici sur 3 bits : ADD = 000 ; SUB = 001 ; ROR = 010 ; ROL = 011 ; AND = 100.
EXERCICE 6
1. Ce module doit-il être séquentiel ou combinatoire ?
2. Décrire cette unité de calcul en VHDL (fichier alu.vhd).
5.4. Le contrôleur
Le contrôleur est l’organe principal du microprocesseur. C’est lui le chef d’orchestre du système. En fonction des
instructions qui se succèdent, il doit décoder les instructions, les opérandes, mettre en relation les différents organes de
traitement et enfin exécuter ces instructions.
Dans cet exemple, nous allons reprendre le cycle du PIC16F84 pour réaliser une machine à états. FETCH, DECODE,
EXECUTE, WRITEBACK seront les 4 états possibles de cette machine qui se succéderont.
Le décodage des sorties sera réalisé dans un second processus.
EXERCICE 7
1. Faire le diagramme d’état de la machine à états fournie dans le fichier source
controleur.vhd.
2. Associer le nom aux différents états. A quoi servent chacune des étapes ?
3. Quelles sont les valeurs des sorties pour chacun de ces états ?
4. Quel type de machine à états est utilisé dans cet exemple ?
6. Test de l’application
EXERCICE 8
1. Faire l’organigramme du programme stocké dans la ROM.
2. Tester le fonctionnement du système :
(a) l’horloge du processeur sera réalisée avec un bouton poussoir (clkslow)
(b) l’horloge du processeur sera reliée à l’horloge de la carte d’étude (clk)
3. Modifier le programme et tester à nouveau.
– 25 –
IUT Créteil - GEII - MC-ENSL1 - Composants programmables complexes
– 26 –
COURS / TP
Téléchargement
Random flashcards
Le lapin

5 Cartes Christine Tourangeau

Anatomie membre inf

0 Cartes Axelle Bailleau

Fonction exponentielle.

3 Cartes axlb48

Créer des cartes mémoire