Vous êtes sur la page 1sur 23

IUT de l'Indre

Dpartement Gnie Electrique et Informatique Industrielle

Module ENSL1 : Initiation au langage VHDL


Travaux Diriges
Eric PERONNIN

Chateauroux, le 13 octobre 2012


2
Table des matires

Exercice 1 : Dcodeur binaire 4 bits vers acheur 7 segments . . . . . . . . . . . . . . . . . 5

Exercice 2 : Compteur/dcompteur synchrone binaire 4 bits reset asynchrone . . . . . . . 5

Exercice 3 : Unit arithmtique et logique 7 oprations . . . . . . . . . . . . . . . . . . . . . 10

Exercice 4 : Module de gestion des registres d'un processeur . . . . . . . . . . . . . . . . . . 13

Exercice 5 : Mmoire de programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Exercice 6 : Mmoire de donnes (Megawizard for Custom Megafonctions de Quartus) . . . 16

Exercice 7 : Unit d'excution du microcontrleur IUT . . . . . . . . . . . . . . . . . . . . . 16


4
Exercices de base

Exercice 1 : Dcodeur binaire 4 bits vers acheur 7 segments


Objectif
Acher les chires 0 9 et lettres allant de A F pour reprsenter en hexadcimal la grandeur d'entre

du dcodeur.

Cahier des charges


Le systme est totalement combinatoire. Le signal entre sous une forme vectorielle compose de 4 bits

(un std_logic_vector sur 4 bits).

Il en rsulte en sortie 7 signaux scalaires reprsentant les dirents segments d'un acheur 7 segments :

signaux a, b, c, d, e, f, g.

Travail raliser
Dresser la table de vrit du dcodeur.

Dcrire en VHDL le bloc fonctionnel correspondant de trois manires direntes.

Tester chacune des versions du dcodeur.

Exercice 2 : Compteur/dcompteur synchrone binaire 4 bits reset asynchrone


6
Problme : Processeur IUT

Ce problme propose la ralisation d'un coeur de microprocesseur tel que ceux prsents dans de nombreux

microcontrleurs. Ce processeur, dsign processeur IUT car ne reposant sur aucun modle connu, possde

les caractristiques suivantes :

jeu d'instructions rduit (36 dans sa version pdagogique de base),

mmoire de programme interne au processeur limite 1024 mots (10 bits d'adresse pour accder aux

instructions),

mmoire de donnes interne de 256 octets,

calculs s'eectuant sur 8 bits et reposant sur l'emploi de 4 registres internes de calcul nots r0 , r1 , r2 et

r3 (les registres sont des mmoires internes au processeur utilises pour la ralisation de calculs divers).

Un avant got du cours d'informatique industrielle du module I2


Introduction

Un coeur de processeur est une unit de traitement squentielle dont le fonctionnement, rythm par

un signal d'horloge, permet d'excuter divers traitements lmentaires cods dans une mmoire appele

mmoire de programme. L'ensemble des informations contenues dans la mmoire de programme constitue un

programme informatique. Les dirents traitements lmentaires possibles reposent sur diverses instructions

pouvant ncessiter plusieurs cycles d'horloge pour tre excutes :

aectations,

oprations arithmtiques et logiques,

comparaisons,

sauts conditionns ou non conditionns vers une instruction autre que l'instruction immdiatement

suivante dans le processus squentiel.

Ces traitements permettent de manipuler des donnes d'origines varies :

mmoires internes du processeur connues sous le nom de registre,

mmoire RAM de donnes adjointe au processeur et accessible en lecture et en criture par l'interm-

diaire des bus de donnes, d'adresse et de contrle,

mmoires de priphriques permettant des liaisons diverses avec l'environnement externe au processeur

et la ralisation de fonctions cables spciques en dehors du processeur dans le but de l'assister.

Exemple de programme - Assembleur

Voici un exemple simple de programme crit en assembleur processeur IUT :


8

adresses mnmoniques oprandes commentaires


0 mov r0 , 1 0 ; r 0 < 10 l e r e g i s t r e r 0 r e o i t l a v a l e u r 10
1 mov r1 , 2 3 0 ; r 1 < 230
2 add r1 , r 0 ; r 1 < r 1 + r 0
3 mov ( 2 5 ) , r1 ; l ' emplacement mmoire 25 r e o i t l a v a l e u r de r 1
4 mov r2 , 17 ; r 2 < 17
5 sub ( 2 5 ) , r2 ; ( 2 5 ) < ( 2 5 ) r 2
6 and r0 , ( 2 5 ) ; r 0 < r 0 and ( 2 5 )
7 jump 2 ; s a u t e l ' i n s t r u c t i o n de l ' a d r e s s e 2 : pc < 2

Cet exemple montre un programme mettant en jeu quelques instructions du processeur IUT avec r0 , r1 ,
r2 et la donne situe l'adresse 25 de la ram comme oprandes. Le mnmonique mov permet de raliser

des aectations, add assure des additions, sub des soustractions, and permet de raliser un et logique bit

bit alors que l'instruction jump permet de rompre le droulement squentiel en spciant l'adresse de la

prochaine instruction excuter.

Prsentation du jeu d'instructions


Le tableau prsent ci-dessous prsente l'ensemble du jeu d'instructions du processeur IUT dans sa

version pdagogique de base (il est tout fait envisageable de l'tendre en exploitant des possibilits de

codage laisses libres) :

Table 1  jeu d'instructions du processeur IUT

Dans ce tableau, 16 colonnes numrotes de 0 15 reprsentent les 16 bits constituant le code machine

d'une instruction. Ces 16 bits sont les suivants (en partant du bit de poids fort) :

alu (bit 15) indique si l'unit arithmtique et logique du processeur est utilise (dans ce cas alu = '1' ).

m1 et m0 (bits 14 et 13) prcisent le mode d'adressage dans le cas o l'unit arithmtique et logique

est employe. Cela renseigne sur les oprandes mis en jeu, en particulier sur la nature de l'oprande de

destination et sur celle de l'oprande source.

 Pour m1 = '0' et m0 = '0', la destination est un registre et la source est un emplacement mmoire

de la mmoire de donnes.
9

 Pour m1 = '0' et m0 = '1', la destination est un registre et la source est une information littrale

code sur 8 bits.

 Pour m1 = '1' et m0 = '0', la destination est un registre et la source est galement un registre.

 Pour m1 = '1' et m0 = '1', la destination est un emplacement de la mmoire de donnes et la source

est un registre.

op2, op1 et op0 (bits 12, 11 et 10) renseignent sur l'opration que doit raliser l'unit arithmtique

et logique lorsque celle-ci est utilise (les dtails seront vus lors de l'tude de l'unit arithmtique et

logique au cours de l'exercice 1).

rd1, rd0 (bits 9 et 8) indiquent le numro de registre de destination lorsque l'instruction code en

ncessite un.

oprandes (bits 7 0) revt direntes formes en fonction du mode d'adressage. La description qui suit

n'a de sens que si l'unit arithmtique et logique est utilise :

 Pour m1 = '0' et m0 = '0', ces 8 bits donnent l'adresse dans la mmoire de donnes de la donne

exploiter comme source.

 Pour m1 = '0' et m0 = '1', les 8 bits d'oprandes fournissent l'oprande source sous la forme d'un

littral cod sur 8 bits.

 Pour m1 = '1' et m0 = '0', seuls les bits 7 et 6 sont exploits. Ils fournissent le numro du registre

source utiliser lors d'une opration arithmtique ou logique.

 Pour m1 = '0' et m0 = '1', les 8 bits d'oprandes prcisent l'adresse dans la mmoire de donne de

la valeur code sur 8 bits exploiter comme oprande source.

Lorsque l'instruction excuter n'exploite pas l'unit arithmtique et logique, le dcoupage des 16 bits est

dirent. Par exemple, l'instruction jump repose sur un code machine faisant apparatre le code 011111

suivi de l'adresse de l'instruction vers laquelle eectuer le saut.

Codage d'un programme en langage machine


Dans la mmoire de programme, on trouve donc une liste de codes machines sur 16 bits rprsentant

chacun une instruction.

Reprenons le programme donn en exemple. A l'adresse 0, on a un mov r0,12, ce qui correspond une

instruction de type mov rd, lit. Le code correspondant dans la mmoire de programme commencera donc

par 10100000 00001100 .

On peut appliquer cette technique de codage chacune des instructions du programme :

adresses c o d e s machine mnmoniques oprandes


0 1 01 000 00 0000 1100 mov r0 , 1 2
1 1 01 000 01 1110 0110 mov r1 , 2 3 0
2 1 10 100 01 0000 0000 add r1 , r 0
3 1 11 000 01 0001 0111 mov ( 2 5 ) , r1
4 1 01 000 10 0001 0001 mov r2 , 17
5 1 11 101 10 0001 0001 sub ( 2 5 ) , r2
6 1 00 001 00 0001 0001 and r0 , ( 2 5 )
7 011111 0000000010 jump 2

Note : pour plus de lisibilit, le code machine des instructions utilisant l'unit arithmtique et logique a

t dcoup par groupe de bits : le bit alu, les bits du mode d'adressage, les bits du code opration, le registre

de destination (source dans le cas d'une aectation vers la mmoire), puis les bits soit du registre source,

soit de l'adresse mmoire cible, soit du littral aecter. Dans le cas du branchement, le code machine

est propos en 2 parties : une pour indiqu un jump et l'autre pour spcier l'adresse de l'instruction o

s'eectue le saut.

Prsentation de la structure interne du microcontrleur IUT


Pour son fonctionnement, ce processeur exploite dirents modules interconnects entre eux :
10

une mmoire de programme qui contient les instructions excuter : cette mmoire possde une largeur

de 16 bits (elle renvoit des donnes sur 16 bits correspondant au codage d'une instruction excuter)

et une profondeur de 1024 mots (elle ncessite qu'on lui fournisse une adresse code sur 10 bits). Le

chier VHDL associ la mmoire de programme s'appellera program_memory (tude et ralisation

pratique dans l'exercice 3).

une mmoire de donnes utilise pour stocker les variables du programme nomme data_memory et

ralise l'aide du MegaWizard Plug-in Manager de Quartus. Sa taille est limite 256 octets (bus

d'adresse et de donnes tous deux sur 8 bits). Voir l'exercice 4 pour plus de dtails.

l'unit arithmtique et logique nomme alu de l'exercice 1. C'est l'unit de calcul du processeur. Elle

travaille avec deux oprandes cods sur 8 bits, eectue une opration indique par le biais de 3 bits

(et, ou, ou exclusif, +, -) dont elle renvoit le rsultat sur 8 bits

le module de gestion des registres de calcul interne au processeur de l'exercice 2 (module registers ).

une unit d'excution mettant en jeu dirents processus. Elle constitue le module principal du pro-

cesseur.

La gure 1 montre les liaisons entre les dirents blocs constituant la version de base du microcontrleur IUT

en intgrant les lments propres au coeur de processeur ainsi que les mmoires de programme et de donnes.

Les dirents exercices qui suivent proposent la ralisation progressive des lments qui apparassent sur ce

schma. Une grande importance sera donne au test unitaire de chacun de ces modules an de garantir le

succs du fonctionnement de l'ensemble une fois constitu comme sur ce schma.

Exercice 3 : Unit arithmtique et logique 7 oprations

Objectif

Raliser la description d'une unit arithmtique et logique simple capable d'eectuer 7 oprations.

Cahier des charges

Le fonctionnement du systme est totalement combinatoire.

Les entres du module raliser sont :

operand_a : premier oprande.

operand_b : second oprande.

operation : mot de 3 bits prcisant l'opration eectuer.

reset : entre de remise 0.

clk : entre d'horloge du processeur.

ag_we : signal de validation pour la mmorisation des indicateurs c_out et z_out.

Les signaux de sortie sont :

result : mot de 8 bits contenant le rsultat de l'opration.

c_out : indicateur de retenue sur 1 bit pour l'addition.

z_out : indicateur sur 1 bit prcisant que le rsultat obtenu est nul.

Tableau des direntes oprations :


11

Figure 1  structure du microcontrleur IUT sous Quartus


12

Table 2  tableau des oprations de l'unit arithmtique et logique


Remarques :

Avec les bibliothques habituelles, les oprations arithmtiques sur des signaux de types std_logic_vector

ne sont pas possibles (on ne peut pas utiliser l'oprateur + de la somme avec des std_logic_vector ). Par

contre, le paquetage numeric_std de la bibliothque ieee propose des types, les types unsigned et signed,

tous deux bass sur des std_logic autorisant une conversion de ces types depuis et vers des std_logic_vector

de faon directe et pour lesquels les oprateurs arithmtiques ont t dnis.

L'exemple suivant montre comment les utiliser :

a r c h i t e c t u r e r t l o f exemple i s
s i g n a l a , b , c : s t d _ l o g i c _ v e c t o r ( 7 downto 0 ) ;
begin
a <= " 0 1 0 0 1 0 1 0 " ;
b <= " 1 1 1 1 0 0 0 0 " ;
c <= s t d _ l o g i c _ v e c t o r ( u n s i g n e d ( a ) + u n s i g n e d ( b ) ) ;
end r t l ;

Dans cet exemple, on cre trois signaux a, b et c vectoriels de 8 std_logic de large.

Pour raliser la somme de a et de b, on a recours une double conversion. La premire permet de convertir

a en unsigned et b en unsigned. Les deux unsigned rsultants sont alors ajouts puis convertis en retour en

std_logic_vector.

Est-il possible de faire plus simple ?

Bien sr ... en utilisant un paquetage dnissant les additions sur les std_logic_vector !

library ieee ;
use i e e e . std_logic_arith . a l l ;
use i e e e . std_logic_unsigned . a l l ;
u s e i e e e . s t d_ lo g ic _1 1 64 . a l l ;
u s e i e e e . numeric_std . a l l ;
...
...
a r c h i t e c t u r e r t l o f somme i f
begin
a <= " 0 1 0 0 1 0 1 0 " ;
b <= " 1 1 1 1 0 0 0 0 " ;
c <= a + b ;
end r t l ;

Prcision concernant la soustraction :

On peut raliser la soustraction en utilisant l'addition du complment 2 de la valeur soustraire (ici

ce sera donc le complment 2 de operand_b).

Travail exig
1. Ralisation simple : modle purement combinatoire ne prenant pas en charge la retenue et
le zero.
Analyser le problme et proposer des ides pour le traitement.
13

Coder le programme.

Tester les direntes oprations l'aide de vecteurs entrs dans un chier de test VHDL.

2. Implmentation du zero et de la retenue.


La sortie z_out indique si le rsultat d'une opration est nulle. Elle est calcule uniquement pour les

oprations 1 7 ce qui signie que son tat ne doit pas changer lorsque l'opration 0 (result <= operand_b )

est slectionne.

La retenue c_out est calcule dans le cas des oprations arithmtiques uniquement. Lorsqu'une autre

opration est ralise, l'tat de c_out doit tre conserv pour reter la dernire opration arithmtique

ralise.

c_out et z_out sont donc des grandeurs mmorises. Leur mmorisation utilise le signal d'horloge clk

d'une part et s'eectue lorsque l'entre ag_we est valide d'autre part.

Note 1 : le signal ag_we est fourni par le module execution_unit un moment o il est connu que les

donnes calcules pour c_out et z_out sont pertinentes.

Note 2 : lorsque reset = '1', les signaux c_out et z_out sont remis 0 sans autre condition (on dit que

le reset est prioritaire).

Le calcul de c_out obit aux quations suivantes :

cas d'une soustraction : c_out <= operand_a7 .operand_b7 +operand_b7 .result7 +result7 .operand_a7
cas d'une addition : c_out <= operand_a7 .operand_b7 + operand_b7 .result7 + result7 .operand_a7
Lorsque son calcul est ncessaire, z_out obit quand lui l'quation suivante :

z _out <= result7 .result6 .result5 .result4 .result3 .result2 .result1 .result0

Implmenter ces deux indicateurs.

Tester le fonctionnement du module nalis.

Exercice 4 : Module de gestion des registres d'un processeur


Objectif
Crer un module permettant de grer les registres du futur processeur IUT.

Cahier des charges


Ce module permet de grer 4 registres 8 bits dnomms : r0 , r1 , r2 et r3 .
Il doit permettre de mettre jour l'tat de ces registres partir de la sortie de l'unit arithmtique et

logique connecte l'entre reg_in et de conserver leurs valeurs le reste du temps.

Les entres sont les suivantes :

clk : horloge du processeur.

reset : l'entre d'initialisation du systme ( la mise 0, les 4 registres sont remis 0 : r1 <= 00000000

...).

dest_reg(1..0) : mot de 2 std_logic indiquant le numro du registre mettre jour (00 pour r0

11 pour r3 ).
reg_in(7..0) : vecteur de 8 std_logic contenant la valeur sur 8 bits stocker dans le registre de desti-

nation indiqu par dest_reg.

reg_we : signal de type std_logic autorisant la mise jour du registre spci par dest_reg. Si reg_we

= '1' et qu'un front montant de l'horloge clk intervient alors le registre spci par dest_reg reoit la

valeur de reg_in.

Les sorties sont :


14

r0(7..0), r1(7..0), r2(7..0) et r3(7..0) : les 4 registres 8 bits du processeur IUT dont l'tat est mmoris

dans l'attente d'une mise jour indique par reg_we..

Fonctionnement :

Le reset est prioritaire (donc asynchrone) et provoque la mise 0 des dirents registres.

Lors d'un front montant d'horloge, si reg_we = '1' alors le registre dont le numro est indiqu par

dest_reg reoit la valeur prsente sur l'entre reg_in. Par exemple, au front montant d'horloge, si

reg_we = '1' et que dest_reg = 10 alors r2 <= reg _in.

Travail demand
Donner une table de vrit de synthse du module registers.

Dcrire ce module en langage VHDL (on appellera l'entit registers et le chier VHDL associ sera

nomm registers.vhd )

Tester le module dans dirents cas de gures choisis susamment exhaustifs.

Exercice 5 : Mmoire de programme


Il s'agit de dcrire le module program_memory en langage VHDL.

Dans le respect des rgles, il est bien clair que ce module devrait reposer sur une mmoire ROM telle

que celle que propose Altera dans son Megawizard. En eet, dans le cas d'une implmentation par Quartus

avec un bloc ddi, c'est une portion de la mmoire embarque dans le FPGA (les fameux M4K) qui sera

gnralement exploite. A contrario, la description combinatoire impose dans cet exercice utilisera des

lments logiques uniquement, consommant ainsi en grand nombre des portes logiques qui auraient pu servir

toute autre chose (le but d'un M4K est exclusivement d'tre exploit dans une fonction de mmoire).

Ainsi, le module program_memory est un programme VHDL combinatoire reposant sur une table de

vrit renvoyant un code machine sur 16 bits en sortie pour une adresse sur 10 bits fournie en entre.

Dans le cas du programme fourni en exemple, la table de vrit mise en place est la suivante :

prg_address prg_data
0 1010 0000 0000 1100
1 1010 0001 1110 0110
2 1101 0001 0000 0000
3 1110 0001 0001 0111
4 1010 0010 0001 0001
5 1111 0110 0001 0001
6 1000 0100 0001 0001
7 0111 1100 0000 0010

Le codage de cette table de vrit en l'tat prsente un problme de lisibilit vident : qui se souviendra

que l'adresse 0 renferme une instruction mov r0, 12 ?

A des ns d'essais et en attendant de disposer d'un logiciel assembleur capable de passer d'un source

contenant des mnmoniques un chier excutable contenant une suite de codes machines, on aura trs cer-

tainement besoin d'un moyen permettant de spcier les codes machines dans le chier program_memory.vhd

avec davantage de souplesse.

Le code prsent ci-dessous propose une approche exploitant des constantes et l'oprateur de concatna-

tion pour raliser un codage plus explicite :


15

library ieee ;
use i e e e . numeric_std . a l l ;
use i e e e . s t d_ lo g ic _ 11 64 . a l l ;
use i e e e . std_logic_arith . a l l ;
use i e e e . std_logic_unsigned . a l l ;

e n t i t y program_memory i s p o r t (
prg_address : i n s t d _ l o g i c _ v e c t o r ( 9 downto 0 ) ;
prg_data : out s t d _ l o g i c _ v e c t o r ( 1 5 downto 0 )
);
end e n t i t y ;

a r c h i t e c t u r e r t l o f program_memory i s
c o n s t a n t r 0 : s t d _ l o g i c _ v e c t o r ( 1 downto 0 ) := " 0 0 " ;
c o n s t a n t r 1 : s t d _ l o g i c _ v e c t o r ( 1 downto 0 ) := " 0 1 " ;
c o n s t a n t r 2 : s t d _ l o g i c _ v e c t o r ( 1 downto 0 ) := " 1 0 " ;
c o n s t a n t r 3 : s t d _ l o g i c _ v e c t o r ( 1 downto 0 ) := " 1 1 " ;
c o n s t a n t i_reg_ram : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 1 0 0 " ;
c o n s t a n t i_reg_reg : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 1 1 0 " ;
c o n s t a n t i _ r e g _ l i t : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 1 0 1 " ;
c o n s t a n t i_ram_reg : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 1 1 1 " ;
c o n s t a n t op_mov : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 0 0 0 " ;
c o n s t a n t op_and : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 0 0 1 " ;
c o n s t a n t op_or : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 0 1 0 " ;
c o n s t a n t op_xor : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 0 1 1 " ;
c o n s t a n t op_add : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 1 0 0 " ;
c o n s t a n t op_sub : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 1 0 1 " ;
c o n s t a n t op_not : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 1 1 0 " ;
c o n s t a n t op_cmp : s t d _ l o g i c _ v e c t o r ( 2 downto 0 ) := " 1 1 1 " ;
c o n s t a n t i_jump : s t d _ l o g i c _ v e c t o r ( 5 downto 0 ) := " 0 1 1 1 1 1 " ;
begin
p r o c e s s ( prg_address )
begin
c a s e prg_address ( 9 downto 0 ) i s
when "0000000000" =>
prg_data <= i _ r e g _ l i t & op_mov & r 0 & s t d _ l o g i c _ v e c t o r ( to_unsigned ( 1 2 , 8 ) ) ;
when "0000000001" =>
prg_data <= i _ r e g _ l i t & op_mov & r 1 & s t d _ l o g i c _ v e c t o r ( to_unsigned ( 2 3 0 , 8 ) ) ;
when "0000000010" =>
prg_data <= i_reg_reg & op_add & r 1 & r 0 & " 0 0 0 0 0 0 " ;
when "0000000011" =>
prg_data <= i_ram_reg & op_mov & r 1 & s t d _ l o g i c _ v e c t o r ( to_unsigned ( 2 5 , 8 ) ) ;


A vous de p o u r s u i v r e l e codage en e x p l o i t a n t c e s p r e m i e r s exemples .

when o t h e r s =>
prg_data <= " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " ;
end c a s e ;
end p r o c e s s ;
end r t l ;

Travail demand
Ajouter le module program_memory.vhd votre projet.

Reprendre l'exemple fourni ci-dessous et le complter.

Proposer une procdure et la mettre en oeuvre pour valider le bon fonctionnement de la mmoire de

programme.
16

Exercice 6 : Mmoire de donnes (Megawizard for Custom Megafonctions de


Quartus)
Exercice 7 : Unit d'excution du microcontrleur IUT
Objectif
Raliser l'unit d'excution d'un processeur 8 bits disposant d'un jeu d'instructions rduit : le microcon-

trleur IUT.

La ralisation de ce module va comporter de nombreuses tapes au cours desquelles dirents processus

seront implments.

Prsentation de l'unit d'excution (execution_unit dans notre projet) - Fonc-


tionnement
L'unit d'excution est le module qui va prendre en charge les instructions en provenance de la mmoire

de programme et dispatcher les informations utiles aux dirents modules du processeur pour mener bien

l'excution de l'instruction. En particulier, elle comunique l'unit arithmtique et logique ses dirents

signaux d'entre ; elle ralise l'interface avec la mmoire de donnes et elle assure la mmorisation des

registres en cas d'volution de leur valeur lors de l'excution d'une instruction.

Reprenons une version allge du premier exemple de programme :

adresses mnmoniques oprandes commentaires


0 mov r0 , 1 2 ; r 0 < 12 l e r e g i s t r e r 0 r e o i t l a v a l e u r 12
1 mov r1 , 2 3 0 ; r 1 < 230
2 add r1 , r 0 ; r 1 < r 1 + r 0
3 mov ( 2 5 ) , r1 ; l ' emplacement mmoire 25 r e o i t l a v a l e u r de r 1
4 and r0 , ( 2 5 ) ; r 0 < r 0 and ( 2 5 )
5 jump 2 ; s a u t e l ' i n s t r u c t i o n de l ' a d r e s s e 2 : pc < 2

L'excution de ce programme s'eectue en de nombreuses tapes :

Phase d'initialisation
 A la mise sous tension, une impulsion de reset est transmise au processeur IUT an de l'initialiser.

 Les registres (r0 , r1 , r2 et r3 ) sont tous remis 0 ; le registre pc pour program counter est galement

initialis 0 pour pointer vers l'instruction situe l'adresse 0 de la mmoire de programme (i.e. la

premire instruction de notre programme).

 L'excution d'une instruction s'eectuant systmatiquement en 4 cycles d'horloge, un compteur de

cycle retant le niveau d'avancement dans l'excution de l'instruction en cours est initialis un

tat Q0 (il voluera ensuite vers l'tat Q1 , puis Q2 , puis Q3 pour revenir Q0 ; le cycle se rptant

indniment).

Adresse 0 : mov r0, 12


 Le compteur de cycle se trouve en Q0 et le front montant d'horloge apparat :

Le processeur charge l'instruction qui se trouve l'adresse 0 : mov r0, 12 et incrmente immdia-

tement le compteur de programme pc (pc pc + 1). Note : cette instruction est stocke dans un

signal vectoriel not instruction. On a donc instruction = 1010 0000 0000 1100 .

L'unit d'excution du processeur envoie r0 l'operand_a de l'unit arithmtique et logique. Elle

attribue la valeur 00001100 operand_b et transmet le code opration 000 au signal operation

de l'alu.

La destination tant le registre r0 , l'unit d'excution xe le signal dest_reg 00 pour le module

registers.

 Au front descendant de l'horloge, le compteur de cycle passe en Q1 : rien faire.

 Au front descendant de l'horloge, le compteur de cycle passe en Q2 : rien faire.

 Au front descendant de l'horloge, le compteur de cycle passe en Q3 :


17

La sortie de l'alu est dirig vers l'entre reg_in du module registers (dans les faits, la sortie de

l'alu sera toujours dirige vers reg_in ).

Le signal reg_we est positionn '1' pour autoriser l'criture dans le registre r0 lors du prochain

front montant d'horloge (reg_we ne conservera cette valeur que durant ce cycle Q3 ).
 Au front montant d'horloge suivant, alors que le compteur de cycle est en Q3 , le module registers

mmorise dans r0 la valeur prsente sur reg_in.

 On repasse au Q0 au front descendant d'horloge.

Adresse 1 : mov r1, 230


 mme traitement en 4 cycles d'horloge que pour l'instruction prcdente. Seul le registre de desti-

nation change (dest_reg = 01 ). L'operand_b reoit quand lui la valeur 230 code en binaire non

sign.

Adresse 2 : add r1, r0


 on reprend les cycles Q0 Q3 de l'instruction prcdente en changeant ceci au cycle Q0 :

operand_a reoit la valeur stocke dans r1 . operand_b reoit la valeur prsente dans r0 . operation
reoit la valeur 100 correspondant l'addition.

dest_reg reoit 01 pour indiquer le registre de destination.

Notes :

Ce sont les bits 9 et 8 du mot instruction qui renseigne sur le numro de registre de destination.

Les bits 7 et 6 du signal instruction indique le numro du registre source.

Les bits 12 10 du signal instruction donne le code de l'opration raliser dans l'unit arithm-

tique et logique.

 Durant le cycle Q3 et uniquement pour ce cycle, l'unit d'excution autorise l'criture sur le registre

destination en xant reg_we = '1'.

Adresse 3 : mov (25), r1


 Cycle Q0 , au front montant d'horloge :

Le processeur charge l'instruction qui se trouve l'adresse 3 : mov (25), r1 et incrmente imm-

diatement le compteur de programme pc (pc pc + 1). On a donc instruction = 1110 0001 0001

1001 .

L'adresse 25 est transmise la ram an d'accder la donne qui y est stocke (pas utile dans le

cas d'un mov ) et de prparer l'accs pour l'criture du rsultat qui interviendra au cycle Q3 .
Les donnes suivantes sont envoyes l'unit arithmtique et logique :

operand_a reoit la donne provenant de la ram (elle ne sera pas utile mais le traitement est le

mme que pour les autres instructions faisant appel l'unit arithmtique et logique dans le cas

d'une destination en mmoire).

Remarque : en Q0 , cette donne n'est pas ncessairement la bonne car la lecture ncessite un cycle
d'horloge supplmentaire et l'adresse vient seulement d'tre fournie la mmoire ram.

operand_b est aect par la valeur stocke dans le registre de travail r1 .


Le code operation est x 000 .

 Rien de se passe au cycle Q1


 Au front descendant d'horloge durant le cycle Q2 , le compteur de cycle passe en Q3 et l'autorisation

d'criture dans la ram (ram_we = '1') est fournie la mmoire de donne. Cette autorisation sera

maintenue durant tout le cycle Q3 .


 Cycle Q3 , front montant d'horloge :

Le signal result prsent la sortie de l'unit arithmtique et logique et transmis au dbut du cycle

Q3 l'entre data de la mmoire de donnes est mmorise par cette mme mmoire.

 Passage en Q0 au front descendant d'horloge.


Adresse 4 : and r0, (25)
 Cycle Q0 , au front montant d'horloge :
Le processeur charge l'instruction qui se trouve l'adresse 4 : mov r0, (25) et incrmente imm-
18

diatement le compteur de programme pc (pc pc + 1). On a donc instruction = 1000 0100 0001

1001 .

L'adresse 25 est transmise la ram an d'accder la donne qui y est stocke.

Les donnes suivantes sont envoyes l'unit arithmtique et logique :

operand_a est aect par la valeur stocke dans le registre de travail r0 .


operand_b reoit la donne provenant de la ram.

Remarque : en Q0 , cette donne n'est pas ncessairement la bonne car la lecture ncessite un cycle
d'horloge supplmentaire et l'adresse vient seulement d'tre fournie la mmoire ram. Cependant,

operand_b tant calcul par un processus combinatoire (ni plus ni moins qu'un multiplexeur

comme nous le verrons plus loin), il prendra la valeur adquate lorsqu'elle sera disponible la

sortie q de la mmoire de donnes. La sortie result de l'unit arithmtique et logique tant elle

mme dcrite par un processus combinatoire, elle sera alors immdiatement mise jour au moment

de la mise en place de la bonne valeur de l'operand_b.

Le code operation est x 001 (pour le and ).

 Rien de se passe au cycle Q1


 Au front descendant d'horloge durant le cycle Q2 , le compteur de cycle passe en Q3 et l'autorisation

de mise jour des registres (reg_we = '1') est fournie au module registers. Cette autorisation sera

maintenue durant tout le cycle Q3 .


 Cycle Q3 , front montant d'horloge :

Le signal result prsent la sortie de l'unit arithmtique et logique et transmis au dbut du cycle

Q3 l'entre data de la mmoire de donnes est mmorise par cette mme mmoire.

 Passage en Q0 au front descendant d'horloge.

Adresse 5 : jump 2
 Le compteur de cycle se trouve en Q0 et le front montant d'horloge apparat :

Le processeur charge l'instruction qui se trouve l'adresse 5 : jump 2 et incrmente immdiatement

le compteur de programme pc (pc pc + 1).


Note : on a instruction = 0111 1100 0000 0010 .

 Front montant d'horloge durant le cycle Q1 :

l'unit d'excution aecte pc avec la valeur de l'adresse atteindre pour la prochaine instruction.

Ici, on saute l'adresse 2 donc pc recevra la valeur 2.

 Pas de traitement supplmentaire durant les cycles restants.

La simulation temporelle du processeur excutant ce programme donne les chronogrammes suivants :


19

Figure 2  chronogrammes du processeur excutant le programme exemple


20

Sur ce graphique, cycle reprsente cycle_counter sous la forme d'un std_logic_vector.

Conception, ralisation et test des dirents processus du module de l'unit


d'excution
Vue externe impose de l'unit d'excution
Elle est prsente gure 3.

Figure 3  symble de l'unit d'excution


Les entres/sorties de l'unit d'excution sont les suivantes :

Signaux gnraux :
 clk : le signal d'horloge du processeur.

 cycle : signal de sortie sur 2 bits indiquant le numro du cycle en cours dans le traitement d'une

instruction.

 reset : entre de remise 0 de l'unit d'excution.


Signaux ralisant l'interfaage avec la mmoire de programme
 prg_data : entre sur 16 bits correspondant la donne pointe dans la mmoire de programme.
 prg_address : sortie sur 10 bits spciant l'adresse dans la mmoire de programme de la prochaine
instruction excuter.

Signaux d'interfaage avec la mmoire de donnes :


 ram_data : entre sur 8 bits contenant la donne actuellement lue dans la mmoire de donnes.

 ram_address : sortie sur 8 bits indiquant l'adresse de la donne cible dans la mmoire de donnes.

 ram_we : signal binaire indiquant la mmoire de donnes si une criture doit tre eectue au

prochaine front montant d'horloge.


21

Signaux d'interfaage avec l'unit arithmtique et logique :


 alu_operand_a : sortie sur 8 bits fournissant l'operand_a (dit de destination) l'unit arithmtique

et logique.

 alu_operand_b : sortie sur 8 bits fournissant l'operand_b (dit source) l'unit arithmtique et

logique.

 alu_operation : entre/sortie sur 3 bits spciant l'opration raliser au sein de l'unit arithmtique

et logique.

 alu_ag_we : sortie prcisant l'unit arithmtique et logique si les indicateurs doivent tre mis

jour.

 alu_c : entre recevant la retenue actuellement mmorise dans l'unit arithmtique et logique.
 alu_z : entre recevant l'indicateur de zro actuellement stock dans l'unit arithmtique et logique.
Signaux d'interfaage avec le module de gestion des registres internes :
 r0, r1, r2, r3 : entres reues du module registers donnant les 4 registres internes du processeurs
(tous sur 8 bits).

 reg_we : sortie indiquant au module registers que la mise jour d'un registre doit tre ralise au

prochain front montant d'horloge.

 dest_reg : entre/sortie sur 2 bits spciant le numro du registre interne mettre jour.

Travail prparatoire
Copier dans votre dossier ENSL1 le dossier processeur stock dans le dossier @partage_lecture\ENSL1\

Ce dossier contient une version du projet corrige avec les dirents modules dj dvelopps jusqu'ici ainsi

qu'un chier execution_unit.vhd contenant essentiellement la description externe du module execution_unit.

Processus numro 1 : Squenceur d'instruction (cycle_counter )


L'excution d'une instruction s'eectue en 4 cycles d'horloge nots Q0 Q3 . An d'assurer le squen-

cement de l'excution, on doit disposer tout instant d'un compteur l'intrieur de l'unit d'excution

indiquant le cycle de calcul en court.

En vous inspirant du cours, crer un type numr pouvant prendre les valeurs Q0 , Q1 , Q2 et Q3 .
Raliser un processus permettant de passer successivement de Q0 Q1 , de Q1 Q2 ...... de Q3 Q0

chaque front descendant de l'horloge.

Notes :

le cycle en cours du processeur sera mmoris dans un signal not cycle_counter.

le reset sera prioritaire et remettra le systme dans son tat Q0 .

Processus numro 2 : Processus squentiel d'excution des instructions


C'est le processus le plus important de l'unit d'excution.

Il gre l'volution du compteur de programme pc et prlve l'instruction prsente sur le bus de donnes

de la mmoire de programme au front montant d'horloge qui intervient lorsque le compteur de cycle est

l'tat Q0 .
Note : le code de l'instruction sera mmoris dans un signal intermdiaire nomm instruction (vecteur

de 16 std_logic ) et dclar entre le mot cl architecture et son begin.

Ajouter la dclaration du signal instruction au programme.

Ecrire le processus de gestion de pc en tenant compte des points suivants :

 le reset est prioritaire et entrane la mise 0 de pc.

 Quand un front montant d'horloge se prsente alors que le compteur de cycle est en Q0 :

Mmoriser le signal prg_data en provenance de la mmoire de programme dans le signal interne

instruction.

Incrmenter pc pour pointer vers l'instruction suivante.


22

 Lors d'un front montant d'horloge pendant le cycle Q2 :

Tester si l'instruction en cours d'excution est un jump.

Si oui, changer la valeur de pc en imposant l'adresse indique dans le code instruction du jump.

 Pour l'instant, ne rien faire pour les cycles Q1 et Q3 .


Tester le fonctionnement de l'bauche de processeur avec le programme exemple exploit jusqu'ici.

En oprant comme pour l'instruction jump, mettre en place le dcodage et l'excution des instructions

de sauts conditionns skipifz (on incrmente pc si z=1 ) et skipifc (incrmentation de pc si c=1 ).

Note : les instructions skipifz et skipifc seront testes plus tard.

Processus numro 3 : Envoi des oprandes operand_a et operand_b l'unit arithmtique et


logique
Il s'agit d'crire un processus combinatoire (ceci implique que les sorties de ce processus reoivent sys-

tmatiquement une valeur lors du traitement du process) permettant de fournir les oprandes l'unit

arithmtique et logique.

Note : l'exemple ci-dessous apporte une illustration sur le caractre combinatoire ou squentiel d'un

process.

a r c h i t e c t u r e r t l o f exemple i s
s i g n a l a , b : s t d _ l o g i c _ v e c t o r ( 3 downto 0 ) ;
begin
l e p r o c e s s u s proc_1 e s t un p r o c e s s u s s q u e n t i e l c a r
s i a vaut "0101" a l o r s b e s t mmoris
e t ne r e o i t pas de n o u v e l l e v a l e u r .
proc_1 : p r o c e s s ( a )
begin
i f a /= "0101" then b <= a ; end i f ;
end p r o c e s s ;
l e p r o c e s s u s c i d e s s o u s e s t c o m b i n a t o i r e c a r b r e o i t
t o u j o u r s une v a l e u r l o r s du t r a i t e m e n t du p r o c e s s u s .
process (a)
begin
i f a = "0000" then b <= " 1 0 1 0 " ; e l s e b <= a ; end i f ;
end p r o c e s s ;
end r t l ;

Analyse du jeu d'instructions En se rfrant au tableau dcrivant les direntes instructions du pro-

cesseur IUT, on peut constater que :

operand_a = rd et operand_b = data_ram pour les instructions mov rd,(ram) cmp rd,(ram)

operand_a = rd et operand_b = lit pour les instructions mov rd,lit cmp rd,lit

operand_a = rd et operand_b = rs pour les instructions mov rd,rs cmp rd,rs

operand_a = data_ram et operand_b = rs pour les instructions mov (ram),rs cmp (ram),rs

o rd reprsente le registre de destination identi dans le code instruction par les bits 9 et 8 (00 pour le

registre r0 ...),

o rs spcie le registre source identi dans le code instruction par les bits 7 et 6 (00 pour le registre

r0 ...) dans le cas des instructions de la classe mov rd,rs et par les bits 9 et 8 dans le cas des instructions de

la catgorie mov (ram),rs,

et o data_ram est le mot de 8 bits destination ou en provenance de la mmoire de donnes.

Travail demand
Dresser une table de vrit faisant apparatre :

 En entres : les 3 bits de poids forts du code machine contenu dans le vecteur instruction.

 En sorties : operand_a et operand_b.


23

Notes : les sorties recevront dirents signaux tels que data_ram, rd, rs, lit (le poids faible du code

machine instruction) ...Par ailleurs, il est possible de prlever les 3 bits de poids forts du signal

instruction en crivant instruction(15 downto 13) dans le code VHDL.

Dcrire cette table de vrit dans un processus combinatoire.

Attention : on ne pourra pas crire operand_a <= rd dans le programme. Il faudra utiliser les bits du signal

instruction spciant rd (dest _reg en fait) pour faire le choix de r0 , r1 , r2 ou encore r3 . La mme dmarche

devra tre mise en oeuvre pour la source rs.

Tester l'intgralit du processeur, observer l'volution des signaux d'oprandes de l'unit arithmtique

et logique et vrier leur cohrence avec le programme de test.

Processus numro 4 : Gnration du signal reg_we autorisant la mise jour du registre de


destination
Il s'agit d'un processus combinatoire. Lorsque l'instruction en cours cible un registre appel registre de

destination et repr par le signal dest_reg, le signal reg_we doit tre mis '1' durant le cycle Q3 du

compteur de cycle. Le reste du temps, reg_we reoit la valeur '0'.

Travail demand
Coder ce 4ime process et le tester.

Note : ce stade, le processeur est capable de raliser une aectation vers un registre.

Processus numro 5 : Gnration du signal ram_we autorisant la mise jour d'une donne
dans la mmoire de donnes
Il s'agit nouveau d'un processus combinatoire. Lorsque l'instruction en cours cible ma mmoire de

donne comme destination (instructions de type (ram),rs ), le signal ram_we doit tre mis '1' durant le

cycle Q3 du compteur de cycle. Le reste du temps, ram_we reoit la valeur '0'.

Travail demand
Coder ce 5ime process et le tester.

Note : ce stade, le processeur est capable de mmoriser la valeur d'un registre l'intrieur de la mmoire

de donnes.

Processus numro 6 : Gnration du signal ag_we autorisant la mise jour ds indicateurs


de l'unit arithmtique et logique
Il s'agit encore une fois d'un processus combinatoire. Lorsque l'instruction en cours utilise l'unit arith-

mtique et logique, le signal ag_we doit tre mis '1' durant le cycle Q3 du compteur de cycle. Le reste

du temps, ag_we reoit la valeur '0'.

Travail demand
Coder ce 6ime process et le tester.

Note : ce stade, l'unit arithmtique et logique est rendue totalement fonctionnelle. Les indicateurs z et

c informent sur le rsultat de certaines oprations dans l'unit arithmtique et logique et il est possible

d'exploiter les instructions de sauts conditionns skipifz et skipifc.