TP Electronique Numérique

TP Electronique Numérique

ENSICAEN 1ère année

Table des matières

1 Fonctions combinatoires & VHDL 3

1.1 L'additionneur 1 bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.1.1 Création d'un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.1.2 Créer une nouvelle source (composant) . . . . . . . . . . . . . . . . . . . . . . . . 4

1.2 L'additionneur 4 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.3 L'additionneur-soustracteur 4 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Transcodage et a�chage 10

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.2 Décodeur Hexa - 7 segments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.2.1 Préparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.2.2 Synthèse logique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.2.3 Simulation du fonctionnement du circuit hex_7seg . . . . . . . . . . . . . . . . . 12

2.2.4 Fichier de contraintes et test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.3 Multiplexage des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.3.1 Réalisation du multiplexage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.3.2 Codage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.4 Génération des signaux de sélection : sel(1 :0) . . . . . . . . . . . . . . . . . . . . . . . . 14

2.4.1 Préparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.4.2 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.5 Le décodeur complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3 Systèmes séquentiels 16

3.1 Les mémoires en logique combinatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3.1.1 Structure interne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.1.2 La mémoire �28C64� . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.1.3 Mémoire et fonctions combinatoires . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.2 Le compteur décompteur entre 1 et 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.3 Le compteur marche/arrêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.4 Le générateur de nombre aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1

TABLE DES MATIÈRES 2

3.4.1 Etape 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.4.2 Etape 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4 La division 21

4.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.1.1 Principe de la division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.1.2 Algorithme de la division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.2 Réalisation matérielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.2.1 Shéma de principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.3 Réalisation de l'unité de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.3.1 Conception de l'unité de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.3.2 Codage de la machine d'états . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.4 L'unité de traitement codée en VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.5 La division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Chapitre 1

Fonctions combinatoires & VHDL

Les fonctions combinatoires sont indispensables au fonctionnement de tout système numérique. La

table de vérité d'une fonction combinatoire constitue son ADN, elle fournit des informations claires sur

son mode de fonctionnement.

En pratique, toute fonction combinatoire est représentée par des portes logiques simples ET, OU,

INV. Pour utiliser le moins de portes possible, on passe par la table de KARNAUGH pour simplier la

fonction. C'est une recette simple mais qui comporte beaucoup de risques d'erreurs d'inattention !

Les outils de synthèse modernes n'ont guère besoin de cette étape fastidieuse, il su�t de leur fournir

la table de vérité, ils s'occupent du reste.

1.1 L'additionneur 1 bit

� Compléter la table de vérité de l'additionneur :

ci a b co s

0 0 0

0 0 1

0 1 0

0 1 1

1 0 0

1 0 1

1 1 0

1 1 1

� La réalisation pratique se fera sur un composant de type FPGA. La description sera faite en

langage VHDL. Le code sera traduit en portes logiques par l'outil de synthèse. L'implémentation

va générer un �chier de con�guration qui, une fois chargé dans le composant, va générer les portes

logiques nécessaires et les connecter comme il se doit pour réaliser l'additionneur.

3

CHAPITRE 1. FONCTIONS COMBINATOIRES & VHDL 4

1.1.1 Création d'un projet

� Démarrer le logiciel VIVADO

� Créer un nouveau projet File > New Project

� Project Type : RTL Project

� Choisir le type de composant

� Clic sur Next après avoir véri�é le résumé

� Plusieurs fenêtres s'ouvrent : celle de gauche décrit toutes les étapes à franchir avant d'arriver à

la programmation du composant

1.1.2 Créer une nouvelle source (composant)

� Add Source >�> Create File


� Renseigner les noms et les modes des entrées sorties

� Compléter le code de l'additionneur

� Les éventuelles erreurs apparaissent dans la fenêtre messages� Ensuite, il est conseillé de simuler le fonctionnement de l'additionneur pour le valider dé�nitive-

ment.

� Run Simulation >�> Run Behavioral Simulation

� On obtient un résultat de simulation pour lequel les entrées sont inconnues (U). Il faut donc


choisir les valeurs des entrées. Par exemple, on peut �xer une valeur constante à une entrée :

Click droit sur 'a' >�> Force Constant.

� On peut également choisir un signal carré : Click droit sur 'b' >�> Force Clock. Choisir lesniveaux logiques et la période :

� Fixer les valeurs des entrées pour tester toutes les combinaisons possibles des entrées a, b et ci.

� Run >�> Run For : Choisir 1µs.

� Véri�er le bon fonctionnement du circuit.

� Remarque : Pour refaire une simulation sans avoir à redé�nir les valeurs des entrées à chaque

fois, on peut sauvegarder les commandes tcl dans un �chier : File >�> New File. Renseignerle nom : addi.tcl. Copier/Coller les commandes tcl à partir de la fenêtre Tcl Console.


� Simuler à nouveau : Tools >�> Run Tcl Script >�> addi.tcl

� Simulation >�> Close Simulation.� Avant la synthèse et l'implémentation, il faut a�ecter les entrées sorties à des broches spéci�ques

du composant. Cela se fait dans le �chier de contraintes. Créer un nouveau �chier de contraintes.

� Choisir son nom

� Compléter le �chier de contraintes en vous aidant du �chier constructeur Nexys4_TP.XDC


� Generate bitsteam (en bas de la fenêtre de gauche). La synthèse et l'implémentation prennent

du temps, il faut être patient.

� Open Hardware Manager pour programmer le composant et véri�er le fonctionnement sur la

maquette.

1.2 L'additionneur 4 bits

� L'additionneur 4 bits est construit avec 4 additionneurs 1 bit en cascade. Vu de l'extérieur, il

ressemble à cela :

� Structure interne :


� Coder le bloc addi4 et le simuler.

� Modi�er le �chier de contraintes, générer le �chier bitstream et tester le fonctionnement sur la

maquette.

1.3 L'additionneur-soustracteur 4 bits

� Le soustracteur 4 bits est réalisé avec un additionneur 4 bits. Comme A−B = A+(−B), on fait

le compément à 2 de B, c'est à dire complément à 1 + 1. B est inversé pour complémenter à 1,

ci est mise à 1 pour faire +1.

� La �gure suivante donne la vue externe de l'additionneur soustracteur (l'entrée op remplace ci) :

� Structure interne de l'additionneur soustracteur :

� Coder le bloc add_sous4 et le simuler.

� Modier le �chier de contraintes, générer le �chier bitstream et tester le fonctionnement sur la

maquette.

Chapitre 2

Transcodage et a�chage

2.1 Introduction

Sur la maquette Nexys4, il y a 8 a�cheurs à 7 segments qui reçoivent tous les mêmes données à

a�cher. Heureusement, chaque a�cheur possède un signal de sélection qui permet d'allumer un a�cheur

à la fois. En faisant tourner rapidement la sélection individuelle des a�cheurs, l'÷il humain a l'impression

de les voir tous allumés en même temps. Dans ce TP, seuls 4 a�cheurs seront utilisés

� Pour commencer, il faut créer un décodeur hexadécimal vers 7 segments qui transforme un code

binaire sur 4 bits en 7 signaux qui a�chent le caractère correspondant sur l'a�cheur.

� Ensuite, il faudra gérer la rotation des données sur les a�cheurs, ainsi que la sélection individuelle,

à une fréquence su�samment élevée par rapport à le persistance rétinienne.

� Le langage VHDL sera utilisé pour décrire et simuler tous les modules du projet.

10

CHAPITRE 2. TRANSCODAGE ET AFFICHAGE 11

2.2 Décodeur Hexa - 7 segments

2.2.1 Préparation

� Le décodeur reçoit 4 signaux (code hexadécimal) et en fournit 8 à l'a�cheur (7 segments + le

point décimal).

� L'a�cheur de la maquette est de type anodes communes comme le montre la �gure précédente.

� Compléter la table de vérité du décodeur en considérant que le point décimal est toujours éteint.

hex(3 :0) dp seg(6 :0)

2.2.2 Synthèse logique

� Créer un nouveau projet, nommé TP2. Choisir le langage VHDL pour ce projet.


� Créer un nouveau module VHDL nommé hex_7seg.vhd dont la vue externe est représentée par

la �gure suivante :

� Coder le décodeur sous forme de table de vérité, en utilisant la structure with ... select.

2.2.3 Simulation du fonctionnement du circuit hex_7seg

� Créer un simulateur (testbench) nommé hex_7seg_tb.vhd permettant de tester toutes les

combinaisons possibles sur les entrées hex(3 :0).� Valider le bon fonctionnement du décodeur.

2.2.4 Fichier de contraintes et test

� Pour véri�er le fonctionnement du décodeur sur la maquette, il faut a�ecter à chaque entrée/sortie

une broche physique du composant.

entrée/sortie broche/composant

hex(3 :0) SW(3 :0)

seg(6 :0) seg(6 :0)

dp dp

� Créer un nouveau �chier de contraintes nommé contraintes.xdc. Le compléter en s'aidant du

�chier fourni par le fabricant de la carte.

� Procéder à la synthèse logique, la compilation et à la génération du �chier de con�guration

(Bitstream).

� Programmer le composant et tester le fonctionnement du décodeur. Comment fonctionnent les 8

a�cheurs ?

2.3 Multiplexage des données

Pour cette application, on souhaite a�cher la valeur hexadécimale des 16 switchs sur les 4 a�cheurs

de droite. Les 4 a�cheurs de gauche seront éteints. Cette application nécessite de pouvoir s'adresser


séparément aux a�cheurs par une broche de sélection, tout en présentant les 4 bits concernant l'a�cheur

sélectionné au décodeur Hexa-7segments.

2.3.1 Réalisation du multiplexage

Cette étape consiste à réaliser le multiplexage des 16 signaux d'entrée nommés data_i(15 :0) vers

les 4 sorties data_o(3 :0). La sélection se fera par 2 �ls nommés sel(1 :0) et le choix de l'a�cheur se

fait à l'aide du bus an(7 :0).

Le tableau suivant explique le mode de sélection.

sel(1 :0) a�cheur sélectionné an(7 :0) donnée a�chée

00 1 11111110 data_i(3 :0)

01 2 11111101 data_i(7 :4)

10 3 11111011 data_i(11 :8)

11 4 11110111 data_i(15 :12)

2.3.2 Codage

� Créer un nouveau module VHDL nommé mux_4a�.vhd dont la vue externe est représentée

par la �gure précédente.

� Coder le multiplexeur sous forme de table de vérité, en utilisant la structure with ... select. Le

simuler.


2.4 Génération des signaux de sélection : sel(1 :0)

2.4.1 Préparation

L'évolution de l'entrée sel permet de choisir l'a�cheur et les données qui le concernent. Il faut faire

évoluer la valeur sel de façon su�samment rapide pour balayer les 4 a�cheurs sans que l'÷il humain ne

s'aperçoive du clignotement. On choisit une période de rafraichissement de l'ordre de 2.6 ms. Un diviseur

de fréquence permet d'obtenir cette fréquence à partir de l'horloge de la platine fclk = 100MHz.

� sachant que la période de clk vaut Tclk = 10ns, une division de fréquence 218 permet de fournir

un signal de période Tsel = 218 · 10ns = 2, 6ms.

� Un compteur binaire à 18 bits (17 : 0) est utilisé comme diviseur de fréquence. La sortie sel(1)

est connectée au bit 17 du compteur, la sortie sel(0) au bit 16.

2.4.2 Synthèse

� Le code diviseur.vhd est fourni, le simuler et valider les résultats.


2.5 Le décodeur complet

� Créer un nouveau module VHDL nommé a�chage.vhd dont la vue externe est représentée par

la �gure précédente.

� Modi�er le �chier de contraintes ou le compléter.

� Compiler le projet, programmer le composant cible et tester le fonctionnement sur la maquette.

� Simuler le décodeur complet si le fonctionnement n'est pas convaincant.

Chapitre 3

Systèmes séquentiels

Les circuits logiques sont classés en deux catégories : combinatoires et séquentiels. Un circuit combi-

natoire se caractérise par le fait que l'état de ses sorties ne dépend que de l'état de ses entrées. C'est le

cas du décodeur hexadécimal vers 7 segments déjà étudié.

Par contre, l'état futur des sorties d'un système séquentiel dépendra de l'état des entrées mais aussi

de l'état actuel des sorties. C'est le cas des feux tricolores : si le feu est actuellement vert il passera tout

à l'heure à l'orange, s'il est rouge il passera au vert, ... Il passe de façon séquentielle, du vert à l'orange,

de l'orange au rouge et du rouge au vert.

Pour réaliser un circuit séquentiel, il faut mémoriser l'état présent, et s'en servir pour le calcul de

l'état futur avec une fonction combinatoire. Ce qui donne le schéma fonctionnel suivant, connu sous le

nom de machine de Moore.

3.1 Les mémoires en logique combinatoire

Une mémoire est un composant dans lequel on peut écrire des données numériques. Les mémoires

non volatiles gardent leurs données intactes après coupure de l'alimentation, tandis que les mémoires

volatiles s'e�acent si on coupe leur alimentation. Il existe toute une variété de types de mémoires : les

ROM. sont programmées une fois pour toutes en usine, les PROM sont programmables une seule

fois par l'utilisateur et les EPROM (UVPROM, EEPROM, FLASH) sont programmables et e�açables

16

CHAPITRE 3. SYSTÈMES SÉQUENTIELS 17

par l'utilisateur. Existe-t-il une analogie entre le fonctionnement d'une mémoire et celui d'une fonction

combinatoire ?

3.1.1 Structure interne

Une mémoire est organisée sous forme de cases à N bits chacune. Chaque case est identi�ée grâce à

son numéro appelé adresse. Cette adresse s'obtient par décodage de la combinaison binaire d'un ensemble

de �ls appelé bus d'adresse. Les N bits de chaque case sont sortis sur N �ls constituant le bus de données.

Le bus d'adresses est unidirectionnel tandis que le bus de données est bidirectionnel.

3.1.2 La mémoire �28C64�

C'est la référence de la mémoire qui est utilisée pour la manipulation et dont la �che technique est

jointe.

Préparation :

1. Relever, à partir de la �che technique de la mémoire, le rôle de chacune de ses broches.

2. Relever les valeurs des paramètres suivants : tension d'alimentation, capacité, nombre de cycles

d'écriture et durée de rétention des données.


3.1.3 Mémoire et fonctions combinatoires

Une mémoire peut être utilisée pour réaliser des fonctions combinatoires. Les �ls d'adresses consti-

tuent les entrées de la fonction et les �ls de données les sorties. Les cases mémoires contiennent les

mêmes données que la table de vérité de la fonction. Les seules contraintes sont : le nombre d'entrées

de la fonction doit être inférieur ou égal au nombre de �ls d'adresses de la mémoire, et le nombre de

fonctions réalisables doit être inférieur ou égal au nombre de �ls de données.

Mode opératoire :

1. Faire l'inventaire des entrées et des sorties des fonctions combinatoires à réaliser.

2. A�ecter chaque entrée de fonction à un bit d'adresse de la mémoire et chaque sortie de fonction

à un bit de donnée de la mémoire.

3. Déterminer le contenu de la mémoire à partir des tables de vérité des fonctions combinatoires et

la programmer.

4. Brancher la mémoire conformément à l'étape 2.

3.2 Le compteur décompteur entre 1 et 6

Reprendre la table d'évolution des états du compteur de 1 à 6 établie en TD, la compléter en ajoutant

une entrée principale nommée up/dn au système. Le système est compteur si up/dn = 0 et décompteur

si up/dn = 1.


Travail à e�ectuer :

1. Appliquer le mode opératoire de la section 3.1.3 pour implanter la partie combinatoire de ce

système dans la mémoire 28C64.

2. Le circuit CD40175 (voir datasheet) est utilisé pour la réalisation pratique. Chaque bascule D

du composant est dotée d'une sortie Q et de son inverse /Q. Sur quelles sorties faut-il brancher

les LED à anodes communes pour observer l'état des sorties Q (LED allumée = sortie Q à l'état

logique 1).

3. Compléter le schéma de câblage en faisant apparaitre toutes les connexions nécessaires entre la

mémoire, les bascules, les LED, le poussoir et l'alimentation (Un shéma à compléter est fourni).

4. Réaliser le montage en utilisant comme horloge la sortie TTL du GBF réglé sur une fréquence de

0,5 Hz.

5. Vérier le bon fonctionnement du compteur décompteur.

3.3 Le compteur marche/arrêt

1. Modi�er la table d'évolution des états précédente pour obtenir le fonctionnement suivant : le

circuit compte lorsque l'entrée up/dn = 0 et s'arrête sur la dernière valeur lorsque up/dn = 1.

2. Reprogrammer la mémoire en conséquence.

3. Véri�er le bon fonctionnement du circuit en branchant l'entrée up/dn à 0V puis à +5V .

3.4 Le générateur de nombre aléatoire

3.4.1 Etape 1

1. Passer à une fréquence d'horloge de 1kHz.


2. Brancher l'entrée up/dn à 0V puis à +5V . Observer et expliquer le fonctionnement du montage.

3.4.2 Etape 2

Le montage précédent est modi�é comme le montre la �gure suivante :

1. Quel est l'état des LED lorsque le poussoir est au repos (fermé) puis actionné (ouvert) ?

2. Comment fonctionne le compteur pour les deux états du poussoir ?

3. En déduire le fonctionnement global du circuit pour une fréquence d'horloge de 1kHz.

4. Réaliser le montage et e�ectuer 120 essais en relevant les di�érentes valeurs a�chées par le

compteur.

Chapitre 4

La division

4.1 Présentation

4.1.1 Principe de la division

L'opération de division ne conduit pas à un opérateur arithmétique structuré cascadable ou arbo-

rescent comme l'addition, la soustraction ou la multiplication. Il s'agit d'une opération plus complexe

reposant sur les autres opérateurs. Toutefois, comme pour les autres opérateurs, le principe d'implémen-

tation de la division s'inspire de la manière de diviser 2 nombres à la main. Un exemple est illustré en

Figure 1. En base 10, le diviseur multiplié par des puissances de 10 est soustrait au dividende autant

de fois que possible. En base 2, les multiplications sont avantageusement remplacées par des décalages

à gauche. L'implémentation de la division reprend cette démarche. Elle peut être réalisée de façon logi-

cielle (soft) sur une UAL donnée ou matérielle (hard). Une réalisation hard présente l'avantage d'être

optimisée et donc plus rapide. Ce TD/TP a pour objectif ce type de réalisation hard de diviseur.

4.1.2 Algorithme de la division

De nombreux algorithmes existent pour implémenter une division de nombres binaires. L'algorithme

choisi dans ce TD/TP est l'algorithme sans restauration (Non Restoring Division Algorithm).

Les étapes de cet algorithme sont décrites ci-dessous et un exemple suit dans le tableau 1.

Algorithme de division sans restauration :

� Décalage des registres P et A de 1 bit vers la gauche.

� Si le contenu du registre P est négatif : on additionne le contenu du registre B à P

21

CHAPITRE 4. LA DIVISION 22

� Si le contenu du registre P est positif : on soustrait le contenu du registre B à P

� Si le résultat chargé dans P est négatif on met le bit de poids faible de A (A0) à � 0 � sinon à �

1 �.

� Ces étapes sont répétées N fois, N étant le format des données, ici N=4.

4.2 Réalisation matérielle

4.2.1 Shéma de principe

L'implémentation matérielle de l'algorithme de division nécessite une structure logique avec une

unité de traitement (UT) dédiée aux opérations élémentaires et une unité de contrôle (UC) chargée de

la piloter. Une structure de ce type, celle utilisée dans ce TD/TP, est illustrée en Figure 2. La demande

de division, DIVstart, provient d'une structure supérieure de type coeur de CPU. L'unité de contrôle

(UC) locale de la division hardware génère les signaux de contrôle pour e�ectuer l'algorithme de division

sur l'unité de traitement (UT) dédiée. Les données sont présentées stables en entrée par le coeur de CPU

qui vient chercher les résultats de la division quand le signal DIVend est actif.


L'unité de traitement comprend 3 registres de données et un additionneur/soustracteur. Le registre

A contient le dividende, B stocke le diviseur, P est un registre de travail.

� Le registre A possède trois commandes : LOADA charge le dividende, SHIFTA décale à gauche

A d'un bit et LOADA0 charge le bit de poids faible.

� Le registre B possède une seule commande : LOADB charge le diviviseur.

� Le registre de travail P possède trois commandes : RESETP remet à zéro P, SHIFTP décale à

gauche P d'un bit et LOADP charge le résultat de l'addition-soustraction.

4.3 Réalisation de l'unité de contrôle

L'unité de contrôle doit piloter l'unité de traitement pour y e�ectuer l'algorithme de division. Pour

l'unité de contrôle une structure de machine à états �nis de type Moore est choisie.

4.3.1 Conception de l'unité de contrôle

L'opération de division sera contrôlée par une machine d'états selon le modèle de MOORE.


� Le signal DIVstart démarre l'algorithme. Le registre conserve la valeur du quotient à la �n de

l'algorithme.

� Une sortie DIVend indique quand le résultat est disponible.

� La période de l'horloge de cadencement, clk, de la machine d'état doit être supérieure au temps

de calcul de l'additionneur/soustracteur.

Compétez le tableau suivant en vous inspirant de l'algorithme décrit en 5.1.2.

Description N° loadB resetP shiftP loadP shiftA loadA loadA0 divend

début, attente divstart 0 0 0 0 0 0 0 0 0

charger A et B, reset P 1

décalage 2

charger A0 et P 3

4

5

6

7

8

9

�n 10 0 0 0 0 0 0 0 1

début, attente divstart 0 0 0 0 0 0 0 0 0

Après analyse, des simpli�cations sont possibles et �nalement, seuls 4 signaux de sortie pour l'unité

de contrôle sont nécessaires pour piloter l'unité de traitement (�gure 5).


1. Que représentent les commandes LOADcalc, LOADinit et SHIFT ?

2. Dessiner le diagramme de la machine et coder ses états.

4.3.2 Codage de la machine d'états

Le codage proposé s'inspire directement du modèle de MOORE : 1 bloc mémoire et 2 blocs logiques

combinatoires.

1. Ecrire la table de vérité du module combinatoire etat_suiv, le coder en VHDL et le simuler.

2. Ecrire la table de vérité du module combinatoire sorties, le coder en VHDL et le simuler.

3. Coder le bloc basculeD et le simuler.

4. Créer un nouveau module UC.vhd à partir des blocs etat_suiv, basculeD et sorties selon le

schéma précédent et le simuler.

4.4 L'unité de traitement codée en VHDL

L'unité de traitement comporte un bloc combinatoire (l'additionneur) et trois registres A sur 4bits,

B sur 5bits et P sur 5bits. Pour simpli�er le code, les deux registres P et A seront regroupés en un seul

appelé regPA sur 9 bits.


� Le code UT.vhd de l'unité de traitement est donné, il est inspité du schéma précédent. Le

simulateur UT_tb.vhd est aussi donné.

� Quelle porte logique se trouve dans les carrés contenant un point d'interrogation ?

� Inclure les deux �chiers au projet et valider la simulation en essayant de bien comprendre la forme

des signaux en entrée et en sortie du bloc UT.

4.5 La division

La division, représentée par la �gure suivante, consiste à assembler les 2 unitées créées précédemment.

1. Créer un nouveau module vhdl nommé division.vhd dont l'entité est représentée par le schéma

précédent.

2. Ajouter un �chier de contraintes avec A sur les switchs (7 :4), B sur les switchs (3 :0), divstart

sur BTNC, le quotient sur les LED (3 :0) et divend sur LED(15).

3. Compiler et tester sur la maquette.

4. Simuler la division en cas de non fonctionnement sur la maquette.

TP Electronique Numérique

Documents

Transcript of TP Electronique Numérique