Professional Documents
Culture Documents
du dcodeur.
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.
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
mmoire de programme interne au processeur limite 1024 mots (10 bits d'adresse pour accder aux
instructions),
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 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
aectations,
comparaisons,
sauts conditionns ou non conditionns vers une instruction autre que l'instruction immdiatement
mmoire RAM de donnes adjointe au processeur et accessible en lecture et en criture par l'interm-
mmoires de priphriques permettant des liaisons diverses avec l'environnement externe au processeur
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
version pdagogique de base (il est tout fait envisageable de l'tendre en exploitant des possibilits de
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
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
Pour m1 = '1' et m0 = '0', la destination est un registre et la source est galement un registre.
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
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
Pour m1 = '0' et m0 = '0', ces 8 bits donnent l'adresse dans la mmoire de donnes de la donne
Pour m1 = '0' et m0 = '1', les 8 bits d'oprandes fournissent l'oprande source sous la forme d'un
Pour m1 = '1' et m0 = '0', seuls les bits 7 et 6 sont exploits. Ils fournissent le numro du registre
Pour m1 = '0' et m0 = '1', les 8 bits d'oprandes prcisent l'adresse dans la mmoire de donne de
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
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
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.
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
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
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
Objectif
Raliser la description d'une unit arithmtique et logique simple capable d'eectuer 7 oprations.
z_out : indicateur sur 1 bit prcisant que le rsultat obtenu est nul.
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
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 ;
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.
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 ;
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.
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
Note 2 : lorsque reset = '1', les signaux c_out et z_out sont remis 0 sans autre condition (on dit que
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
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-
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.
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
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
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 )
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
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
Le code prsent ci-dessous propose une approche exploitant des constantes et l'oprateur de concatna-
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.
Proposer une procdure et la mettre en oeuvre pour valider le bon fonctionnement de la mmoire de
programme.
16
trleur IUT.
seront implments.
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
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
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).
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 .
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.
La sortie de l'alu est dirig vers l'entre reg_in du module registers (dans les faits, la sortie de
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
nation change (dest_reg = 01 ). L'operand_b reoit quand lui la valeur 230 code en binaire non
sign.
operand_a reoit la valeur stocke dans r1 . operand_b reoit la valeur prsente dans r0 . operation
reoit la valeur 100 correspondant l'addition.
Notes :
Ce sont les bits 9 et 8 du mot instruction qui renseigne sur le numro de registre de destination.
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
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
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.
d'criture dans la ram (ram_we = '1') est fournie la mmoire de donne. Cette autorisation sera
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.
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.
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 mise jour des registres (reg_we = '1') est fournie au module registers. Cette autorisation sera
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.
Adresse 5 : jump 2
Le compteur de cycle se trouve en Q0 et le front montant d'horloge apparat :
l'unit d'excution aecte pc avec la valeur de l'adresse atteindre pour la prochaine instruction.
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.
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
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
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
cement de l'excution, on doit disposer tout instant d'un compteur l'intrieur de l'unit d'excution
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
Notes :
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
Quand un front montant d'horloge se prsente alors que le compteur de cycle est en Q0 :
instruction.
Si oui, changer la valeur de pc en imposant l'adresse indique dans le code instruction du jump.
En oprant comme pour l'instruction jump, mettre en place le dcodage et l'excution des instructions
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-
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 = 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
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.
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
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
Tester l'intgralit du processeur, observer l'volution des signaux d'oprandes de l'unit arithmtique
destination et repr par le signal dest_reg, le signal reg_we doit tre mis '1' durant le cycle Q3 du
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
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.
mtique et logique, le signal ag_we doit tre mis '1' durant le cycle Q3 du compteur de cycle. Le reste
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