Vous êtes sur la page 1sur 200

Conservatoire National des Arts et Mtiers

Polycopi de cours ELE106

Version du 12/07/2010

Conception numrique en VHDL

C.ALEXANDRE

INTRODUCTION A LA CONCEPTION EN VHDL .............................................................................. 1 1.1 1.2 1.3 1.3.1 FAMILLES DE CIRCUITS INTEGRES NUMERIQUES .................................................................................... 1 LES FPGA............................................................................................................................................. 4 CONCEPTION DUN DESIGN .................................................................................................................... 7 Saisie du design ............................................................................................................................... 7
Saisie de schma ....................................................................................................................................7 Langage de description de bas niveau....................................................................................................7 Langage de description matriel ............................................................................................................8 1.3.1.1 1.3.1.2 1.3.1.3

1.3.2 1.4 1.5 1.5.1 1.5.2

La chane complte de conception en VHDL .................................................................................. 8 LA MAQUETTE FPGA.......................................................................................................................... 10 INTRODUCTION AU LANGAGE VHDL .................................................................................................. 12 Dfinition....................................................................................................................................... 12 Gnralits .................................................................................................................................... 12
Ncessit ..............................................................................................................................................12 Un peu d'histoire ..................................................................................................................................13

1.5.2.1 1.5.2.2

1.5.3

Les principales caractristiques du langage VHDL...................................................................... 14


Un langage s'appliquant plusieurs niveaux de descriptions...............................................................14 La portabilit........................................................................................................................................15 La lisibilit ...........................................................................................................................................15 La modularit .......................................................................................................................................16 Le couple entit architecture ................................................................................................................17 Les principaux objets manipuls ..........................................................................................................18 Les types ..............................................................................................................................................18 Fonctionnement concurrent..................................................................................................................19 Fonctionnement squentiel...................................................................................................................20

1.5.3.1 1.5.3.2 1.5.3.3 1.5.3.4 1.5.3.5 1.5.3.6 1.5.3.7 1.5.3.8 1.5.3.9

1.5.4 1.5.5 1.5.6

VHDL par rapport aux autres langages........................................................................................ 21 Normes et extensions ..................................................................................................................... 22 La synthse .................................................................................................................................... 23
dfinition ..............................................................................................................................................23 La synthse automatique de circuits : dans quel but ?..........................................................................23

1.5.6.1 1.5.6.2

1.5.7 1.5.8 2

Diffrences entre un langage de programmation et VHDL........................................................... 24 Bibliographie................................................................................................................................. 24

LOGIQUE COMBINATOIRE................................................................................................................. 25 2.1 2.1.1 INTRODUCTION,


2.1.1.1 2.1.1.2 2.1.1.3 2.1.1.4 2.1.1.5 2.1.1.6
VARIABLES ET FONCTIONS LOGIQUES ....................................................................... 25

Les oprateurs fondamentaux........................................................................................................ 26


INV (NON) ..........................................................................................................................................26 AND (ET) ............................................................................................................................................26 OR (OU)...............................................................................................................................................27 NAND (NON ET) ................................................................................................................................27 NOR (NON OU) ..................................................................................................................................28 XOR (OU exclusif) ..............................................................................................................................28

2.1.1.7 2.1.1.8

XNOR (NON OU exclusif) ................................................................................................................. 29 Portes universelles ............................................................................................................................... 29

2.1.2 2.1.3 2.1.4

Algbre de BOOLE ........................................................................................................................30 Expression dune fonction logique ................................................................................................32 Simplification des fonctions logiques ............................................................................................33
Simplification algbrique .................................................................................................................... 34 Simplification par les tableaux de Karnaugh ....................................................................................... 34

2.1.4.1 2.1.4.2

2.2 2.2.1 2.2.2 2.2.3 2.2.4 2.2.5 2.2.6 2.2.7

CIRCUITS LOGIQUES COMBINATOIRES..................................................................................................40 Circuits logiques fondamentaux ....................................................................................................40 Le dmultiplexeur ..........................................................................................................................42 Le dcodeur ...................................................................................................................................43 Le multiplexeur ..............................................................................................................................44 Lencodeur de priorit ...................................................................................................................45 Les mmoires .................................................................................................................................46 Buffer bidirectionnel 3 tats ..........................................................................................................47
La porte 3 tats .................................................................................................................................... 47 Notion de bus....................................................................................................................................... 47

2.2.7.1 2.2.7.2

2.3 2.3.1 2.3.2 2.4 2.4.1 2.4.2 2.4.3 2.4.4 2.4.5 2.4.6 2.4.7 2.4.8 2.5 3

CARACTERISTIQUES TEMPORELLES .....................................................................................................50 Caractristiques temporelles .........................................................................................................50 Etats transitoires............................................................................................................................51 DESCRIPTION EN VHDL ......................................................................................................................56 Introduction ...................................................................................................................................56 Portes combinatoires .....................................................................................................................57 Multiplexeurs (mmorisation implicite).........................................................................................60 Assignation inconditionnelle de signal : squentiel contre concurrent .........................................68 Dmultiplexeur - dcodeur ............................................................................................................69 Encodeur de priorit......................................................................................................................71 Mmoire ROM ...............................................................................................................................73 buffer bidirectionnel trois tats......................................................................................................74 EXERCICES ..........................................................................................................................................76

REPRESENTATION DES NOMBRES...................................................................................................83 3.1 3.1.1 LES CODES ...........................................................................................................................................83 Entiers naturels..............................................................................................................................83
Base dun systme de numration ....................................................................................................... 83 Changement de base ............................................................................................................................ 85 3.1.1.1 3.1.1.2

3.1.2 3.1.3

Entiers signs.................................................................................................................................87 Nombres rels ................................................................................................................................89


Virgule flottante................................................................................................................................... 89 virgule fixe .......................................................................................................................................... 90

3.1.3.1 3.1.3.2

3.1.4

Des codes particuliers ...................................................................................................................90

ii

3.1.4.1 3.1.4.2 3.1.4.3 3.1.4.4 3.1.4.5 3.1.4.6

Le code BCD........................................................................................................................................90 Le code Gray........................................................................................................................................91 Le code Johnson...................................................................................................................................93 Le code 1 parmi N................................................................................................................................94 Le code ASCII .....................................................................................................................................94 Les codes dtecteurs et/ou correcteurs derreurs..................................................................................95

3.2 3.2.1 3.2.2 3.2.3 3.2.4 3.2.5 3.3 3.3.1 3.3.2

LES CIRCUITS ARITHMETIQUES ............................................................................................................ 95 Ladditionneur/soustracteur.......................................................................................................... 95 Dbordement de calcul.................................................................................................................. 97 Le comparateur ............................................................................................................................. 98 Le multiplieur ................................................................................................................................ 99 Le diviseur ................................................................................................................................... 102 DESCRIPTION EN VHDL.................................................................................................................... 105 Reprsentation des nombres en VHDL........................................................................................ 105 Le package std_logic_arith ......................................................................................................... 106
Les types signed et unsigned .....................................................................................................106 Les fonctions de conversion...............................................................................................................106 conv_integer .................................................................................................................................106 conv_unsigned ..............................................................................................................................106 conv_signed ..................................................................................................................................107 conv_std_logic_vector ..................................................................................................................107 Conversion de types proches (closely related)..............................................................................107 Oprateur arithmtiques : +, -, * ........................................................................................................108 Oprateurs de comparaison : <, <=, >, >=, =, /= ................................................................................108 Fonctions de dcalage : SHL, SHR ....................................................................................................109

3.3.2.1 3.3.2.2 3.3.2.2.1 3.3.2.2.2 3.3.2.2.3 3.3.2.2.4 3.3.2.2.5 3.3.2.3 3.3.2.4 3.3.2.5

3.3.3 3.3.4

Les packages std_logic_unsigned et std_logic_signed................................................................ 109 Exemples...................................................................................................................................... 110


Additionneur simple non sign ou sign ............................................................................................110 Additionneur avec retenue entrante et sortante ..................................................................................111 Additions multiples sans gestion de retenue ......................................................................................112 Comparateur.......................................................................................................................................113 Multiplieur .........................................................................................................................................116

3.3.4.1 3.3.4.2 3.3.4.3 3.3.4.4 3.3.4.5

3.4 4

EXERCICES ........................................................................................................................................ 117

LOGIQUE SEQUENTIELLE ................................................................................................................ 121 4.1 4.2 4.3 4.4 4.5 4.6 4.6.1 CIRCUITS SEQUENTIELS ASYNCHRONES ............................................................................................. 121 BISTABLES SYNCHRONISES SUR UN NIVEAU ...................................................................................... 127 BASCULES D MAITRE-ESCLAVE (MASTER-SLAVE D FLIP-FLOP) ......................................................... 129 BASCULES D SYNCHRONISEES SUR UN FRONT (EDGE-TRIGGERED D FLIP-FLOP) ................................ 130 BASCULES USUELLES ........................................................................................................................ 131 CARACTERISTIQUES TEMPORELLES DES CIRCUITS SEQUENTIELS SYNCHRONES ................................. 133 Dfinitions ................................................................................................................................... 134

iii

4.6.2 4.6.3 4.6.4 4.6.5 4.7 4.7.1 4.7.2 4.7.3 4.7.4 4.7.5 4.8 4.8.1 4.8.2 4.8.3

Calcul de la frquence maximale dhorloge dune bascule D.....................................................135 Calcul de la frquence maximale dhorloge dans le cas gnral ................................................137 Mtastabilit ................................................................................................................................138 Distribution des horloges : clock skew ..................................................................................140 REGLES DE CONCEPTION ....................................................................................................................143 Influence des alas de commutation ............................................................................................143 Rgles de conception synchrone ..................................................................................................144 Le rle du CE...............................................................................................................................145 Asynchrone contre synchrone......................................................................................................146 Le reset.........................................................................................................................................147 CIRCUITS ELEMENTAIRES ..................................................................................................................152 Les bascules lmentaires............................................................................................................152 Le registre....................................................................................................................................152 Le registre dcalage .................................................................................................................153
Dfinition........................................................................................................................................... 153 Applications....................................................................................................................................... 155 Le SN74LS178, registre dcalage polyvalent de 4 bits .................................................................. 155

4.8.3.1 4.8.3.2 4.8.3.3

4.8.4

Les compteurs ..............................................................................................................................157


Introduction ....................................................................................................................................... 157 Compteurs binaires asynchrones et synchrones................................................................................. 158 Ralisation des fonctions supplmentaires ........................................................................................ 161 Mise en cascade de compteurs........................................................................................................... 162 Ralisation de compteurs modulo quelconque................................................................................... 164 Action sur l'entre Clear synchrone.............................................................................................. 164 Rappel des cas possibles d'alas................................................................................................... 165 Influence de lala ........................................................................................................................ 165 Action sur lentre LOAD synchrone........................................................................................... 167

4.8.4.1 4.8.4.2 4.8.4.3 4.8.4.4 4.8.4.5 4.8.4.5.1 4.8.4.5.2 4.8.4.5.3 4.8.4.5.4

4.8.5 4.8.6 4.8.7 4.8.8 4.9 4.9.1 4.9.2 4.9.3 4.9.4 4.9.5 4.9.6 4.9.7 4.10 5

Laccumulateur de somme ...........................................................................................................167 Laccumulateur de produit : MAC...............................................................................................169 Les monostables...........................................................................................................................170 Circuit de dtection de front ........................................................................................................171 DESCRIPTION EN VHDL ....................................................................................................................172 Latch transparent et bascule D....................................................................................................172 Registre ........................................................................................................................................176 Registre dcalage......................................................................................................................177 Compteur .....................................................................................................................................179 Accumulateur...............................................................................................................................181 MAC.............................................................................................................................................182 Circuit de dtection de front ........................................................................................................183 EXERCICES ........................................................................................................................................184

MONTAGES EN LOGIQUE SEQUENTIELLE..................................................................................193

iv

5.1 5.2 5.2.1 5.2.2 5.2.3 5.3 5.3.1 5.3.2 5.3.3

MACHINES DETATS .......................................................................................................................... 193 LES GENERATEURS DE SEQUENCES SYNCHRONES .............................................................................. 195 Compteur, dcompteur ................................................................................................................ 195 Cas particulier : les registres dcalages boucls ..................................................................... 196 Le gnrateur pseudo-alatoire (LFSR)...................................................................................... 198 DESCRIPTION EN VHDL.................................................................................................................... 200 Description modulaire et paramtres gnriques ....................................................................... 200 Registre dcalage gnrique .................................................................................................... 210 Conception avec plusieurs horloges ou avec plusieurs CE......................................................... 212
Introduction........................................................................................................................................212 Circuit diviseur dhorloge ..................................................................................................................213 Circuit gnrateur de CE....................................................................................................................214

5.3.3.1 5.3.3.2 5.3.3.3

5.3.4 6

Calcul de moyenne mobile........................................................................................................... 215

SIMULATION ET TESTBENCH.......................................................................................................... 225 6.1 6.1.1 6.1.2 6.1.3 6.1.4 6.1.5 6.1.6 6.2 6.3 6.3.1 6.3.2 6.3.3 6.3.4 6.3.5 6.3.6 PRINCIPE DE LA SIMULATION FONCTIONNELLE .................................................................................. 225 Introduction ................................................................................................................................. 225 Testbench simple sans gnration de stimuli .............................................................................. 225 Testbench avec rebouclage combinatoire ................................................................................... 228 Process or not process................................................................................................................. 231 Plusieurs process identiques ....................................................................................................... 233 Gestion des conflits...................................................................................................................... 235 LA SIMULATION POST-IMPLEMENTATION .......................................................................................... 238 ECRITURE DUN TESTBENCH COMPLET .............................................................................................. 245 Ecriture dun testbench combinatoire simple avec gnration de stimuli................................... 245 Arrt automatique de la simulation ............................................................................................. 248 Testbench squentiel.................................................................................................................... 249 Testbench squentiel amlior..................................................................................................... 252 Utilisation du type rel ................................................................................................................ 254 Ecriture dun testbench utilisant des fichiers .............................................................................. 257

CONCEPTION ET PERFORMANCES ............................................................................................... 265 7.1 7.2 7.3 7.3.1 7.3.2 7.3.3 7.3.4 7.3.5 7.3.6 7.4 INTRODUCTION.................................................................................................................................. 265 COMPROMIS SURFACE/VITESSE ......................................................................................................... 266 PROBLEMES LIES A LA CONSOMMATION ............................................................................................ 269 Structure dun circuit CMOS....................................................................................................... 269 Consommation dynamique .......................................................................................................... 270 Consommation statique ............................................................................................................... 274 Caractristiques lectriques ........................................................................................................ 274 Tension dalimentation et puissance ........................................................................................... 275 Mthodes pour limiter la consommation ..................................................................................... 277 AUGMENTATION DE LA FREQUENCE DE FONCTIONNEMENT ............................................................... 277

7.4.1 7.4.2 7.4.3 8

Modles de timing........................................................................................................................277 Mise en uvre des contraintes.....................................................................................................280 Mthode du pipeline ....................................................................................................................282

CORRIGES SUCCINCTS ......................................................................................................................287 8.1 8.2 8.3 CORRIGES CHAPITRE 2.......................................................................................................................287 CORRIGES CHAPITRE 3.......................................................................................................................294 CORRIGES CHAPITRE 4.......................................................................................................................298

TRAVAUX PRATIQUES .......................................................................................................................305 9.1 9.1.1 9.1.2 9.1.3 9.1.4 9.1.5 9.1.6 9.1.7 9.1.8 9.1.9 9.1.10 9.1.11 9.2 9.2.1 9.2.2 9.3 9.3.1 9.3.2 9.4 9.4.1 9.4.2 9.5 9.5.1 9.5.2 9.6 9.6.1 9.6.2 9.7 9.7.1 9.7.2 TRAVAIL PRATIQUE N1....................................................................................................................305 Ouverture de session....................................................................................................................305 Lancement de Project Navigator ...........................................................................................305 Cration du projet........................................................................................................................305 Cration du design VHDL ...........................................................................................................308 Gnration du fichier de stimuli VHDL.......................................................................................311 Simulation fonctionnelle ..............................................................................................................316 Synthse .......................................................................................................................................321 Implmentation ............................................................................................................................325 Simulation de timing ....................................................................................................................330 Configuration de la maquette .................................................................................................332 La suite du TP .........................................................................................................................338 Cahier des charges ......................................................................................................................339 Ralisation pratique.....................................................................................................................340 TRAVAIL PRATIQUE N3....................................................................................................................341 Cahier des charges ......................................................................................................................341 Ralisation pratique.....................................................................................................................342 TRAVAIL PRATIQUE N4....................................................................................................................343 Cahier des charges ......................................................................................................................343 Ralisation pratique.....................................................................................................................349 TRAVAIL PRATIQUE N5....................................................................................................................351 Cration dun testbench avec ISE................................................................................................351 Ralisation pratique.....................................................................................................................357 TRAVAIL PRATIQUE N6....................................................................................................................359 Cahier des charges ......................................................................................................................359 Ralisation pratique.....................................................................................................................360 PROJET ..............................................................................................................................................361 Cahier des charges ......................................................................................................................361 Ralisation pratique.....................................................................................................................364

TRAVAIL PRATIQUE N2....................................................................................................................339

vi

1 Introduction la conception en VHDL


1.1 Familles de circuits intgrs numriques

Il existe une loi empirique, appele loi de Moore, qui dit que la densit dintgration dans les circuits intgrs numriques base de silicium double tous les 18 24 mois, prix du circuit quivalent. Les consquences de la loi de Moore sont les suivantes : La longueur du canal L qui tait gale 10 m dans les annes 1970 a atteint 32 nm en 2010, ce qui fait un facteur de rduction en surface de 3122 100000 en 40 ans (car toutes les dimensions du transistor ont t rduites de la mme manire). Le nombre de transistors par circuits a encore plus augment cause de laccroissement de la taille des puces qui atteint 600 mm2 (avec quelques millions de transistors par mm2). On pourrait atteindre facilement un milliard de transistors par circuit (toujours en 2010). La frquence de fonctionnement a augment dun facteur 10000 environ entre 1970 et 2010. La figure suivante vous montre une paire de transistor MOS canal N et canal P qui forme la brique de base de la logique CMOS :

La loi de Moore sest rvle remarquablement exacte jusqu' ce jour et elle explique en grande partie lvolution de llectronique numrique de ses origines nos jours. Durant les annes 60, au dbut de l're des circuits intgrs numriques, les fonctions logiques telles que les portes, les registres, les compteurs et les ALU, taient disponibles en circuit TTL. On parlait de composants SSI (Small Scale Integration) ou MSI (Medium Scale Integration) pour un tel niveau d'intgration.

Dans les annes 70, le nombre de transistors intgrs sur une puce de silicium augmentait rgulirement. Les fabricants mettaient sur le march des composants LSI (Large Scale Integration) de plus en plus spcialiss. Par exemple, le circuit 74LS275 contenait 3 multiplieurs de type Wallace. Ce genre de circuit n'tait pas utilisable dans la majorit des applications. Cette spcialisation des botiers segmentait donc le march des circuits intgrs et il devenait difficile de fabriquer des grandes sries. De plus, les cots de fabrication et de conception augmentaient avec le nombre de transistors. Pour toutes ces raisons, les catalogues de composants logiques standards (srie 74xx) se sont limits au niveau LSI. Pour tirer avantage des nouvelles structures VLSI (Very Large Scale Integration), les fabricants dvelopprent 4 nouvelles familles : Les microprocesseurs et les mmoires RAM et ROM : les microprocesseurs et les circuits mmoires sont attrayants pour les fabricants. Composants de base pour les systmes informatiques, ils sont produits en trs grandes sries. Les ASSP (Application Specific Standard Product) : ce sont des produits sur catalogue qui sont fabriqus en grande srie. La fonction ralise est fige par le constructeur, mais le domaine dutilisation est spcifique une application. Exemple : un contrleur Ethernet, un encodeur MPEG-4, Les circuits programmables sur site : n'importe quelle fonction logique, combinatoire ou squentielle, avec un nombre fixe d'entres et de sorties, peut tre implante dans ces circuits. A partir de cette simple ide, plusieurs variantes d'architecture ont t dveloppes (PAL, EPLD, FPGA,). Les ASIC (Application Specific Integrated Circuit) raliss chez le fondeur : le circuit est conu par l'utilisateur avec des outils de CAO, puis il est ralis par le fondeur. A l'heure actuelle, la plupart des circuits numriques est issue de ces 4 familles. Cependant, certains lments simples du catalogue standard (famille 74) sont toujours utiliss. Plus simplement, on peut distinguer deux catgories de circuits intgrs : les circuits standards et les circuits spcifiques une application : Les circuits standards se justifient pour de grandes quantits : microprocesseurs, contrleurs, mmoires, ASSP, Les circuits spcifiques sont destins raliser une fonction ou un ensemble de fonctions dans un domaine dapplication particulier. 2

La figure suivante reprsente une classification des circuits intgrs numriques.


CIRCUIT STANDARD Circuit spcifique l'application

conu et ralis par le fabricant

ASIC

Full-custom

Semi-custom

PLD
Circuit la demande Circuit base de cellules Circuit prdiffus Circuit programmable

Circuit compil

Circuit prcaractris

Rseau mer de portes

Rseau prdiffus classique

FPGA PROM PLA PAL EPLD ou CPLD

Dans la littrature, le terme ASIC est employ pour dcrire lensemble des circuits spcifiques une application. Or, dans le langage courant, le terme ASIC est presque toujours utilis pour dcrire les circuits raliss chez un fondeur. On dsigne, par le terme gnrique PLD (Programmable logic Device), lensemble des circuits programmables par lutilisateur. Parmi les circuits numriques spcifiques une application, il faut distinguer deux familles : les circuits conus partir dune puce de silicium vierge (Full-custom), les circuits o des cellules standards sont dj implantes sur la puce de silicium (Semicustom). Dans le premier groupe, les circuits appels Full custom , on trouve les circuits la demande et ceux base de cellules (CBIC : Cell Based Integrated Circuit). Le fondeur ralise l'ensemble des masques de fabrication. Dans le second groupe, les circuits appels Semicustom , on trouve les circuits prdiffuss (GA : Gate Array) et les circuits programmables. Les cellules standards, dj implantes sur la puce de silicium, doivent tre interconnectes les unes avec les autres. Cette phase de routage est ralise, soit par masquage chez le fondeur (prdiffus), soit par programmation. 3

Tous les ASICs ont un point commun ; il est ncessaire de passer par un fondeur pour raliser les circuits. Cela implique une quantit minimale de circuits fabriquer (au moins quelques dizaines de milliers par an) ainsi quun dlai de fabrication de quelques mois. De plus, le cot de fabrication initial (NRE) devient de plus en plus lev (quelques millions de $ en 2010) et doit tre amorti sur des quantits de circuits de plus en plus grandes. Ces inconvnients ont conduit les fabricants proposer des circuits programmables par l'utilisateur (sans passage par le fondeur) qui sont devenus au fil des annes, de plus en plus volus. Rassembls sous le terme gnrique PLD, les circuits programmables par l'utilisateur se dcomposent en deux familles : 1. les PROM, les PLA, les PAL et les EPLD, 2. les FPGA. Dans ce cours, nous allons utiliser une maquette FPGA pour tester nos designs. Voyons plus en dtail cette famille de circuits logiques programmables. 1.2 Les FPGA

Lanc sur le march en 1984 par la firme XILINX, le FPGA (Field Programmable Gate Array) est un circuit prdiffus programmable. Le concept du FPGA est bas sur l'utilisation d'une LUT (LookUp Table) comme lment combinatoire de la cellule de base. En premire approximation, cette LUT peut tre vue comme une mmoire (16 bits en gnral) qui permet de crer nimporte quelle fonction logique combinatoire de 4 variables dentres. Chez Xilinx, on appelle cela un gnrateur de fonction ou Function Generator. La figure suivante reprsente la cellule type de base d'un FPGA.
MUX 2:1 D0 O D1 S LUT 4 entres D CE H Q mmoire

Elle comprend une LUT 4 entres et une bascule D (D Flip-Flop). La bascule D permet la ralisation de fonctions logiques squentielles. La configuration du multiplexeur 2 vers 1 de sortie autorise la slection des deux types de fonction, combinatoire ou squentielle. Les cellules de base d'un FPGA sont disposes en lignes et en colonnes. Des lignes d'interconnexions programmables traversent le circuit, horizontalement et verticalement, entre les cellules. Ces lignes d'interconnexions permettent de relier les cellules entre elles, et avec les plots d'entres/sorties (IOB : Input Output Block).

Les connexions programmables sur ces lignes sont ralises par des transistors MOS dont l'tat est contrl par des cellules mmoires SRAM. Ainsi, toute la programmation d'un FPGA est contenue dans des cellules SRAM. La configuration est le processus qui charge le design dans la SRAM afin de programmer les fonctions des diffrents blocs et de raliser leurs interconnexions. On voit (symboliquement), sur la figure ci-dessous, quil y a sous la logique 5

ddie lapplication une mmoire de configuration qui contient toutes les informations concernant la programmation des CLB et des IOB ainsi que ltat des connexions. Cette configuration est ralise, la mise sous tension, par le chargement dun fichier binaire contenu gnralement dans une mmoire flash srie qui se trouve cot du FPGA sur la carte.

La frquence maximale de fonctionnement d'une fonction logique est difficile prvoir avant son implmentation. En effet, cela dpend fortement du rsultat de l'tape de placementroutage. Cependant, une frquence comprise entre 100 et 200 MHz est un bon ordre de grandeur. Tous les FPGA sont fabriqus en technologie CMOS, les plus gros d'entre eux intgrent jusqu' 10000000 portes logiques utilisables. Leur prix est compris entre 10 et 1000 euros lunit. Par rapport aux prdiffuss classiques, les interconnexions programmables introduisent des dlais plus grands que la mtallisation (environ 3 fois plus lents). Par contre, les cellules logiques fonctionnent la mme vitesse. Pour minimiser les dlais de propagation dans un FPGA, il faut donc rduire le nombre de cellules logiques utilises pour raliser une fonction. Par consquent, les cellules logiques dun FPGA sont plus complexes que celles dun prdiffus.

1.3

Conception dun design

1.3.1 Saisie du design 1.3.1.1 Saisie de schma Le rle de la saisie de schma est dtablir, partir des composants utiliss et de leurs interconnexions, une liste de connectivit (netlist). Cette netlist peut ensuite tre utilise par le simulateur ou bien par les outils de placementroutage. Lutilisateur visualise son design laide de schmas graphiques faciles interprter. Les composants sont reprsents par des symboles graphiques. Les autres outils EDA (Electronic design automation) travaillent partir de la netlist ASCII (ou binaire). 1.3.1.2 Langage de description de bas niveau La saisie de schma est un moyen puissant pour spcifier un design car le schma graphique est une manire naturelle pour un lectronicien de crer ou de lire un design. Elle a toutefois trois inconvnients principaux : Lincompatibilit entre les librairies qui rend le portage dun design entre deux fabricants de FPGA quasiment impossible. La complexit dun schma devient trs leve quand le nombre de portes augmente. Audel de 10000 portes, il devient gnralement ingrable. Une modification importante au milieu dune page du schma ncessite gnralement la rcriture complte de la page. Pour toutes ces raisons, on a essay de dvelopper des outils spcifiant le design avec une entre de type texte plutt quavec une entre de type graphique. Les premiers langages de bas niveau ont t crs pour programmer les PAL puis les PLD. On trouvait principalement les deux langages suivants : PALASM. Il sagissait dun langage de programmation de PAL conu par AMD/MMI. Aujourdhui obsolte, les outils de dveloppement avaient limmense avantage dtre gratuits. ABEL. ABEL tait un langage de programmation de PAL conu par Data I/O. Il a t trs utilis aux USA mais les outils de dveloppement taient assez coteux.

1.3.1.3 Langage de description matriel Les deux langages prcdents taient loin dtre assez puissants pour pouvoir spcifier un ASIC ou un FPGA. Deux langages de description matriel sont apparus dans les annes 80 : Verilog et VHDL (VHSIC (Very High-Speed Integrated Circuit) Hardware Description Language). Les simulateurs et les synthtiseurs ne travaillent plus aujourdhui quavec un de ces deux langages. Le schma graphique, quand il est utilis, est simplement traduit dans un de ces langages. 1.3.2 La chane complte de conception en VHDL Nous allons maintenant voir la chane de dveloppement complte utilisant loutil ISE de la socit Xilinx. Elle comprend les tapes suivantes. 1. Ecriture du modle VHDL avec lditeur intgr du navigateur de projet. Nous allons voir au chapitre suivant une introduction lcriture de modles VHDL synthtisables. Il y a deux parties crire : Lentit (entres/sorties), Larchitecture (la description du fonctionnement). 2. Ecriture du testbench (on utilisera loutil HDL Bencher dans un premier temps). Pour pouvoir simuler le modle VHDL de notre design, il faut crire des vecteurs (stimuli) de test qui forment le testbench. Cette criture se droule en deux phases : dfinition graphique des vecteurs de test, sauvegarde de la saisie graphique et du fichier quivalent en langage VHDL. 3. Simulation fonctionnelle (simulateur ModelSim). A partir des fichiers design.vhd (modle VHDL du design) et design_tb.vhw (vecteurs de test en VHDL), nous pouvons effectuer la simulation fonctionnelle du design. Il y a quatre phases : compilation des fichiers, lancement du simulateur, excution des vecteurs de test, vrification du fonctionnement laide des chronogrammes.

4. Synthse logique avec XST. La synthse est lopration qui consiste, partir du fichier texte, produire la netlist contenant le schma lectrique destin aux outils de placementroutage (fichier au format NGC). Cette tape est particulirement dlicate dans le cas des FPGA cause de la complexit leve (granularit) de la cellule de base du FPGA. La description VHDL nutilise pas de bibliothque propritaire et elle est assez gnrale. La portabilit est donc bien meilleure quavec la saisie de schma (les langages VHDL et Verilog sont normaliss), mais toute la complexit du processus de dveloppement repose maintenant sur lefficacit de la synthse. Le rle du synthtiseur est ici de comprendre et dinterprter une description abstraite du design afin de gnrer un fichier NGC comprhensible par les outils dimplmentation, cest--dire une netlist NGC compose de primitives simples.

la synthse est lopration qui permet de crer une netlist NGC partir dune description de haut niveau crite en VHDL.

5. Implmentation. Le but de limplmentation est de gnrer un fichier de configuration permettant de programmer le FPGA partir du fichier NGC. Le tableau suivant indique les 4 tapes possibles ainsi que les rapports qui lui sont associs.

Etape Translation Mapping

Signification Cration dun fichier de design unique plat (sans hirarchie) Dcoupage du design en primitives existant dans le FPGA

Placement-routage Placement et routage des primitives Assignation des broches du FPGA configuration Gnration du fichier de configuration

6. Simulation temporelle (avec ModelSim). Aprs le placement-routage, on peut obtenir un modle VHDL rel du design (modle VITAL) ainsi que le fichier de timings qui lui est associ (fichier SDF). On utilise le fichier de stimuli gnr par HDL Bencher pour effectuer la simulation de timing du design en quatre phases : compilation des fichiers, lancement du simulateur, excution des vecteurs de test, vrification du fonctionnement laide des chronogrammes. 7. Tlchargement. Une fois le design entirement simul, nous pouvons tlcharger le fichier de configuration du FPGA dans la maquette grce au logiciel Impact : Initialisation de la chane JTAG, Association du fichier .bit avec le FPGA, Tlchargement dans le FPGA. 8. Vrification sur la maquette FPGA. Tous les designs raliss dans ce cours seront tests sur la maquette FPGA. Un design simul mais non test matriellement, cest comme un programme en C que lon aurait compil, mais pas excut. 1.4 La maquette FPGA

La maquette FPGA est constitue : Dun FPGA Xilinx XC3S200-4C en botier BGA 256 broches. Dun CAN 8 bits 32 MSPS (AD9280) prcd dun filtre anti-repliement (Tchebyscheff du 3me ordre, fc = 5 MHz). Le niveau dentre sur la prise Din (adapte 50 ) ne doit pas dpasser 1V crte crte. Le FPGA doit fournir un signal dhorloge (niveau CMOS 3.3V) ce composant. Dun CNA 8 bits 125 MSPS (AD9708) suivi dun filtre de lissage (Tchebyscheff du 3me ordre, fc = 5 MHz). Le FPGA doit fournir un signal dhorloge (niveau CMOS 3.3V) ce composant.

10

Din tlchargement CAN fc = 5 MHz FPGA XC3S200 Dout CNA fc = 5 MHz 50 Hin

D
LD7 LD0

Hi BTN3 BTN0 SW7 SW0 Lo

De quatre afficheurs 7 segments multiplexs (dont trois nomms D (dizaine), U (unit) et P (puissance)). Un segment sallume quand la sortie du FPGA qui lui est connect est au niveau bas.

De 8 leds nommes LD0 LD7. Une led sallume quand la sortie du FPGA qui lui est connecte est au niveau haut. 11

De 8 interrupteurs (Lo/Hi) nomms SW0 SW7. Quand un interrupteur est sur Hi, lentre du FPGA qui lui est connect est au niveau haut.

De quatre boutons poussoirs nomms BTN0 BTN3. Lappui sur un de ces boutons dclenche une impulsion positive (met au niveau 1 lentre correspondante).

Dune entre dhorloge Hin (niveau CMOS 3.3V adapte 50 ). Dun oscillateur 50 MHz (100 ppm, niveau CMOS 3.3V) connect sur le FPGA. Dune prise de tlchargement JTAG pour programmer le FPGA. Le tlchargement seffectue via une des prises parallles du PC.

1.5

Dun cordon dalimentation. Il faut une alimentation 5 V, 1.6 A. Introduction au langage VHDL

1.5.1 Dfinition VHDL sont les initiales de VHSIC Hardware Description Langage, VHSIC tant celles de Very High Scale Integrated Circuit. Autrement dit, VHDL signifie : langage de description matriel s'appliquant aux circuits intgrs trs forte intgration. 1.5.2 Gnralits 1.5.2.1 Ncessit L'volution des technologies induit une complexit croissante des circuits intgrs qui ressemblent de plus en plus aux systmes complets d'hier. Aujourd'hui, on intgre dans une puce ce qui occupait une carte entire il y a quelques annes. La simulation logique globale du systme au niveau "porte" n'est plus envisageable en terme de temps de simulation. C'est donc tout naturellement que des simulateurs fonctionnels ont commenc tre utiliss en microlectronique. Dans les annes 70, une grande varit de langages et de simulateurs tait utilise. Cette diversit avait pour consquence une non portabilit des modles et donc une impossibilit d'change entre les socits. Un des rles de VHDL est de permettre l'change de descriptions entre concepteurs. Ainsi peuvent tre mises en place des mthodologies de 12

modlisation et de description de bibliothques en langage VHDL. L'effort de standardisation d'un langage tel que VHDL tait ncessaire par le fait qu'il ne s'agissait pas de construire un seul simulateur VHDL (contrairement la quasi-totalit des autres langages), mais de permettre l'apparition d'une multitude d'outils (de simulation, de vrification, de synthse, ...) de constructeurs diffrents utilisant la mme norme. Ceci garantit une bonne qualit (la concurrence) et l'indpendance de l'utilisateur vis vis des constructeurs de ces outils. 1.5.2.2 Un peu d'histoire Les langages de description matriel (HDL ou Hardware Description Language) ont t invents la fin des annes 60. Ils s'appuyaient sur les langages de programmation et devaient permettre la description et la simulation de circuits. Entre les annes 1968 et 1975, une grande diversit de langages et de simulateurs ont vu le jour. Cependant, leur syntaxe et leur smantique taient incompatibles et les niveaux de descriptions taient varis. En 1973, le besoin d'un effort de standardisation s'est fait ressentir et c'est ainsi que le projet CONLAN (pour CONsensus LANguage) a t mis en place. Les principaux objectifs de ce projet taient de dfinir un langage de description matriel permettant de dcrire un systme plusieurs niveaux d'abstractions, ayant une syntaxe unique et une smantique formelle et non ambigu. En mars 1980, le dpartement de la dfense des Etats Unis d'Amrique (DoD ou Department of Defense) lanait le programme VHSIC. En 1981, des demandes pour un nouveau langage de description de systmes matriels, indpendant de toute technologie et permettant de couvrir tous les besoins de l'industrie microlectronique, ont t formules. C'est en 1983, que d'importantes socits telles que IBM, Intermetrics ou encore Texas Instruments se sont investies dans ce projet et la fin de l'anne 1984, un premier manuel de rfrence du langage ainsi qu'un manuel utilisateur ont t rdigs. En 1985, des remises en cause et des valuations ont donn naissance la version 7.2 du langage VHDL, et en juillet 1986, Intermetrics a dvelopp un premier compilateur et un premier simulateur. C'est en mars 1986, qu'un groupe charg de la standardisation du langage VHDL a t cr. Il s'agit du groupe amricain VASG (VHDL Analysis and Standardization Group) qui est un sous comit des DASS (Design Automation Standard Subcommittees), eux-mmes manant de l'IEEE (Institute of Electrical and Electronics Engineers). La norme VHDL IEEE 1076 a t approuve le 10 dcembre 1987. En tant que standard IEEE, le langage VHDL volue tous

13

les cinq ans afin de le remettre jour, d'amliorer certaines caractristiques ou encore d'ajouter de nouveaux concepts. Ainsi en 1991 a dbut le processus de re-standardisation : regroupement et analyse des requtes, dfinition des nouveaux objectifs du langage, spcifications des changements apporter au langage. La nouvelle norme du langage VHDL a t vote en septembre 1993. La syntaxe et la smantique de cette nouvelle norme ont donn lieu un nouveau manuel de rfrence. Il est souligner que la nouvelle version du langage VHDL gnralement note VHDL93 est, au moins thoriquement, la seule et unique version lgale du langage. L'approbation de la nouvelle norme VHDL en 1993 rend le standard prcdent (IEEE Std 1076 vot en 1987) dsuet. Nanmoins, et heureusement, VHDL93 reste compatible avec VHDL87. 1.5.3 Les principales caractristiques du langage VHDL 1.5.3.1 Un langage s'appliquant plusieurs niveaux de descriptions Le langage VHDL couvre tous les niveaux partant des portes logiques de base jusqu'aux systmes complets (plusieurs cartes, chacune comprenant plusieurs circuits). Il s'applique tout aussi bien au niveau structurel qu'au niveau comportemental, en passant par le niveau transferts de registres ou RTL (Register Transfer Logic). La description comportementale Le circuit est dcrit sans tenir compte de la ralisation concrte sur un composant donn (Elle ne comporte aucune horloge et les largeurs des bus ne sont pas spcifies.). On utilise les fonctions de haut niveau dabstraction de VHDL. Le code est donc portable, mais il dpend entirement du synthtiseur pour le rsultat (si un tel synthtiseur existait, ce qui nest pas encore le cas). Ce style de description permet en particulier de spcifier le circuit sous forme dun algorithme. La description flot de donnes (RTL) Le circuit est dcrit grce plusieurs couche de registres (bascules D) relies par de la logique combinatoire. On utilise gnralement une liste d'instructions concurrentes d'affectations de signaux du type "<signal> <= <expression> " o <expression> peut reprsenter un simple signal, ou une expression utilisant des oprateurs logiques, arithmtiques ou relationnels, ou une expression conditionnelle. Cest la manire traditionnelle dcrire du VHDL et qui donne 14

gnralement les meilleurs rsultats avec les synthtiseurs commercialiss. Ce niveau de description est souvent appel "logiques transfert de registres" ou RTL (Register Transfer Logic). La description structurelle de bas niveau Le circuit est dcrit par sa structure, sous forme dune liste de composants instancis et des interconnexions les reliant. En fait, cest lquivalent littral dun schma reprsentant linterconnexion de portes lmentaires issues d'une bibliothque.

A B

La description structurelle de haut niveau Le circuit est dcoup en blocs fonctionnels de haut niveau qui sont relis entre eux. Il sagit toujours dun schma, mais il reprsente des composants qui peuvent tre crit en comportemental ou en RTL (mais aussi en structurel bas niveau). On retrouve en gnral ce type de description dans le design suprieur dune description hirarchique (top level design). 1.5.3.2 La portabilit La portabilit constituait un des objectifs principaux pendant la phase de dfinition du langage VHDL. L'utilisation largement rpandue de ce langage est essentiellement due au fait qu'il soit un standard. Un standard offre beaucoup plus de garanties (stabilit, fiabilit, etc.) vis--vis des utilisateurs que ne le permettrait un langage potentiellement prcaire dvelopp par une socit prive. La portabilit signifie dans le cadre des FPGA, quil est possible tout moment de changer de technologie cible (Altera, Xilinx, etc.) ou bien de famille au sein dun mme fabricant ; ou mme davoir une stratgie de conception qui consiste raliser un prototype sur un circuit programmable (FPGA) avant de basculer sur des circuits spcifiques (ASIC). 1.5.3.3 La lisibilit La reprsentation schmatique n'est pas toujours d'une grande lisibilit. Il est difficile de saisir rapidement le fonctionnement d'une machine d'tat parmi un enchevtrement de registres et de portes logiques. Une documentation crite est trs souvent ncessaire la comprhension 15

d'un schma. VHDL apporte par son principe de modularit et d'interconnexion de composants une grande lisibilit permettant la comprhension d'un systme, sans pour autant supprimer l'utilit d'un dessin fonctionnel. 1.5.3.4 La modularit La modularit est une des caractristiques essentielles de VHDL. Une description partitionne en plusieurs sous-ensembles est dite modulaire. VHDL supporte la conception modulaire et hirarchique, qui offre de nombreux avantages : les descriptions sont plus simples, les dures de simulation, de synthse et de mise au point sont raccourcies, la fiabilit est amliore : chaque sous-ensemble peut tre test exhaustivement, les sous-ensembles sont rutilisables.

En VHDL, une description peut donc faire appel des modules externes et les interconnecter de manire structurelle. Par exemple, la vision hirarchique dun additionneur consiste traiter les blocs, ladditionneur et le registre, comme assemblage dobjets plus lmentaires comme le montre la figure suivante.

16

1.5.3.5 Le couple entit architecture Un design quelconque (circuit intgr, carte lectronique ou systme complet) est compltement dfini par des signaux dentres et de sorties et par la fonction ralise en interne. Llment essentiel de toute description en VHDL est form par le couple entit/architecture qui dcrit lapparence externe dun module et son fonctionnement interne. Entit Lentit dcrit la vue externe du modle : elle permet de dfinir les ports par o sont vhiculs les informations (signaux) et les paramtres gnriques. Le code suivant donne un exemple dentit dfinie pour un compteur N bits. Il est possible de dfinir des valeurs par dfaut pour les paramtres ; dans cet exemple, le paramtre WDTH correspond au nombre de bits du compteur avec pour valeur par dfaut 4.
entity compteur is generic (WDTH : integer :=4; STOP : integer :=10); port( CLK : in std_logic ; CE : in std_logic ; CLEAR : in std_logic; CEO : out std_logic; DOUT : out std_logic_vector(WDTH -1 downto 0)); end compteur;

Architecture Larchitecture dfinit la vue interne du modle. Cette description peut tre de type structurel, flot de donnes, comportemental ou une combinaison des trois. Tous les fonctionnements ne ncessitent pas le mme degr de prcision : tantt une description globale permet dobtenir un rsultat satisfaisant, tantt une description trs prcise savre ncessaire. A chaque entit peut tre associe une ou plusieurs architectures, mais, au moment de lexcution (simulation ou synthse), une seule architecture est utilise. Ceci prsente lintrt de comparer plusieurs architectures pour choisir la meilleure. Larchitecture comprend aussi une partie dclarative o peuvent figurer un certain nombre de dclarations (de signaux, de composants, etc.) internes larchitecture. A titre dexemple, le code suivant donne une description possible darchitecture associe lentit dcrite prcdemment pour un compteur N bits.

17

architecture a1 of compteur is signal INT_DOUT : std_logic_vector(DOUT'range) ; begin process(CLK, CLEAR) begin if (CLEAR='1') then INT_DOUT <= (others => '0'); elsif (CLK'event and CLK='1') then if (CE='1') then if (INT_DOUT=STOP-1) then INT_DOUT <= (others => '0'); else INT_DOUT <= (INT_DOUT + 1); end if; end if; end if; end process;
CEO <= INT_DOUT(0) and not INT_DOUT(1) and not INT_DOUT(2) and INT_DOUT(3) and CE;

dout <= int_dout; end;

1.5.3.6 Les principaux objets manipuls Les constantes : Une constante peut tre assimile un signal interne (au circuit) auquel est associe une valeur fixe et dfinitive. La constante peut tre de tout type. Les signaux : Les signaux sont spcifiques la description matrielle. Ils servent modliser les informations qui passent sur les fils, les bus ou, dune manire gnrale, qui transitent entre les diffrents composants. Les signaux assurent donc la communication. Les variables : Une variable est capable de retenir une valeur pendant une dure limite. Elle ne peut tre employe qu lintrieur dun process. A loppos dun signal, une variable nest pas une liaison concrte et ne doit pas laisser de trace aprs synthse. 1.5.3.7 Les types Une des principales caractristiques de VHDL est qu'il s'agit d'un langage fortement typ. Tous les objets dfinis en VHDL doivent appartenir un type avant d'tre utiliss. Deux objets sont compatibles sils ont la mme dfinition de type. Un type dfinit l'ensemble des valeurs que peut prendre un objet ainsi que l'ensemble des oprations disponibles sur cet objet. Puisque VHDL s'applique au domaine logique, les valeurs 0 et 1 peuvent tre considres. L'ensemble de ces deux valeurs dfinit le type BIT. Il est possible de dfinir d'autres valeurs comme par exemple la valeur 'Z' dsignant la valeur trois tats. Un type plus complet, englobant neuf valeurs logiques diffrentes dcrivant tous les tats dun signal lectronique numrique, a t standardis dans la librairie std_logic_1164 : le std_logic. Les valeurs que peut prendre un signal de ce type sont : 18

U X 0 1 Z W L H -

: : : : : : : : :

non initialis, niveau inconnu, forage fort, niveau 0, forage fort, niveau 1, forage fort, haute impdance, niveau inconnu, forage faible, niveau 0, forage faible, niveau 1, forage faible, quelconque.

Les valeurs 0 et L sont quivalentes pour la synthse, tout comme les valeurs 1 et H. Les valeurs U, X et W ne sont utilisables que pour la simulation dun design. Il existe quatre familles de type en VHDL : les types scalaires, dont la valeur est compose d'un seul lment (integer, bit, std_logic, boolean, etc.), les types composs, dont la valeur comprend plusieurs lments (bit_vector, std_logic_vector), les types accs, qui sont les pointeurs des langages de programmation, les types fichiers, qui ne sont utiliss que pour les objets fichiers.

Les deux dernires familles ne sont bien sr pas utilisables pour le dveloppement dun circuit intgr. 1.5.3.8 Fonctionnement concurrent Le comportement d'un circuit peut tre dcrit par un ensemble d'actions s'excutant en parallle. C'est pourquoi VHDL offre un jeu d'instructions dites concurrentes. Une instruction concurrente est une instruction dont l'excution est indpendante de son ordre d'apparition dans le code VHDL. Par exemple, prenons le cas d'un simple latch, comme le montre la figure :

19

S Q

RS

NQ

Les deux portes constituant ce latch fonctionnent en parallle. Une description possible de ce circuit est donne dans le code suivant (seule l'architecture est donne).

architecture comportement of VERROU is begin Q <= S nand NQ; NQ <= R nand Q; end comportement;

Ces deux instructions s'excutent en mme temps. Elles sont concurrentes ; leur ordre d'criture n'est pas significatif ; quel que soit l'ordre de ces instructions, la description reste inchange. 1.5.3.9 Fonctionnement squentiel Les instructions concurrentes qui viennent dtre prsentes pourraient suffire dfinir un langage de description matriel. Cependant, certains circuits sont plus faciles dcrire en utilisant des instructions squentielles similaires des instructions de langages classiques de programmation. En VHDL, les instructions squentielles ne sutilisent qu lintrieur des processus. Un processus est un groupe dlimit dinstructions, dot de trois caractristiques essentielles : Le processus sexcute chaque changement dtat dun des signaux auxquels il est dclar sensible. Les instructions du processus sexcutent squentiellement. Les modifications apportes aux valeurs de signaux par les instructions prennent effet la fin du processus.

20

Lexemple de la description suivante montre une architecture (seule) dun latch D contenant un processus qui est excut lors du changement dtat de lhorloge CLK.

architecture comportement of basc_D is begin Process (CLK) Begin If ( CLK= 1) then Q <= D; End if ; End process ; end comportement;

1.5.4 VHDL par rapport aux autres langages Bien que VHDL soit maintenant largement accept et adopt, il n'est pas le seul langage de description matriel. Pendant ces trente dernires annes, beaucoup d'autres langages ont t dvelopps, ont volu et sont encore utiliss aujourd'hui par les concepteurs de circuits intgrs. Cr pour tre un standard, VHDL doit son succs la fois ses prdcesseurs et la maturit de ses principes de base. Verilog est un langage qui a t dvelopp par une compagnie prive pour ses propres besoins (langage de spcification pour leurs outils de simulation). Verilog a tout d'abord t dcrit par la socit Gateway Design Automation qui a ensuite fusionn avec la compagnie Cadence Design Systems. Pour que Verilog puisse faire face VHDL, Cadence a dcid de le rendre public en 1990. L'utilisation de Verilog est promue par le groupe Open Verilog International (OVI) qui a publi en Octobre 1991 la premire version du manuel de rfrence du langage Verilog. En 1995, Verilog est devenu un standard sous la rfrence IEEE 1364. Du point de vue syntaxique, VHDL s'est largement inspir du langage ADA, alors que Verilog ressemble au langage C. VHDL est certainement le plus difficile utiliser car il reste trs gnral. De plus, il demande l'utilisateur d'avoir des habitudes de programmeur (compilation spare, langage fortement typ, notion de surcharge, etc). Compar Verilog qui reste proche de la ralit physique, VHDL est sans aucun doute plus complexe. Mais il est aussi beaucoup moins ambigu dans ses descriptions du matriel.

21

1.5.5 Normes et extensions Les normes suivantes dfinissent le langage et ses extensions pour la simulation, la synthse et la rtro annotation.

Norme IEEE 1076.1 1076.2 1076.3 1076.4 1164 P1497

sujet 1987 et 1993, IEEE Standard VHDL Language Reference Manual. 1996, IEEE Standard VHDL Mathematical Packages. 1997, IEEE Standard VHDL Synthesis Packages. 1995, IEEE Standard VITAL Application-Specific Integrated Circuit (ASIC) Modeling Specification. 1993, IEEE Standard Multivalue Logic System for VHDL Model Interoperability (Std_logic_1164). Standard for (SDF) Standard Delay Format for the Electronic Design Process

Il existe plusieurs versions de VHDL : VHDL-87, 93, 2000, 2002, 2008 et VHDL-AMS (pour lanalogique). La version 93 est la plus utilise (cest celle que nous utiliserons). Il faut noter que : Le package IEEE 1076.3 concerne la synthse. Il prcise linterprtation des nombres (comment interprter un nombre entier par exemple) ainsi que les packages arithmtiques numeric_bit et numeric_std permettant de traiter les types signed et unsigned ainsi que de nombreuses fonctions de conversion. Hlas, la normalisation a t tardive (1996) et a permis la normalisation de fait des packages de Synopsys std_logic_unsigned, std_logic_signed, std_logic_arith qui sont souvent utiliss la place (notamment par Synopsys). VITAL est une extension de la norme permettant la retro annotation en association avec un fichier SDF. VITAL permet lcriture de modle physique de composant vrifiant entre autres toutes ses caractristiques de timing. Ces timings sont contenus dans le fichier SDF. On crit rarement soi mme un modle VITAL. Cest gnralement loutil de placement routage qui crit le modle rel du design en VITAL et gnre le fichier SDF. Ces deux fichiers sont ensuite utiliss pour la simulation post-implmentation.

22

1.5.6 La synthse 1.5.6.1 dfinition La synthse est dfinie comme une succession d'oprations permettant partir d'une description de circuit dans un domaine fonctionnel (description comportementale) d'obtenir une description quivalente dans le domaine physique (description structurelle). Le processus de synthse peut tre dfini comme une bote noire ayant en entre une description abstraite en termes de langage de description matriel, et comme sortie une description structure en termes de dispositifs interconnects (une netlist). 1.5.6.2 La synthse automatique de circuits : dans quel but ? Le premier intrt de la synthse est de permettre une description la plus abstraite possible d'un circuit physique. Le concepteur a de moins en moins de dtails donner. Par exemple, pour dcrire un compteur, la description dtaille des signaux de contrle explicitement utiliss n'est pas indispensable. Seule la fonctionnalit de comptage et les contraintes de synthse (qui peuvent tre des contraintes de temps, doptimisation, de circuit cible, etc) doivent tre indiques. Le but de l'abstraction est de rduire et de condenser les descriptions au dpart et, par consquent, de faciliter leur correction en cas d'erreurs. L'autre avantage de l'abstraction est la portabilit. Plus l'abstraction est leve, plus la description est portable. En effet, une abstraction leve ne fait pas rfrence un composant cible car elle ne spcifie pas les dtails. Puisque les systmes deviennent de plus en plus complexes, il ne sera bientt plus possible d'envisager leur conception en saisie de schma (sauf pour la saisie du top-level design qui est en gnrale structurelle). Avec la synthse, le nombre d'informations devant tre fournies par le concepteur diminue. Ces informations consistent essentiellement en la description comportementale du circuit et des contraintes correspondantes. La synthse amnera sans aucun doute dans les prochaines annes, des circuits plus srs, plus robustes et devrait, lavenir, tre considre comme une marque de qualit dans le cycle de conception. Puisque la synthse permet de rduire la taille des descriptions, elle permet galement de faciliter les remises jour, de rendre les corrections plus rapides, et de pouvoir explorer un ensemble plus vaste de solutions architecturales (avec la synthse comportementale). Dans ce contexte, le meilleur compromis entre cot et performance peut plus facilement tre atteint par le concepteur. Le grand nombre de descriptions dj existantes coupl avec la possibilit de les 23

paramtrer amnent la cration de ressources de bibliothques rutilisables. Ceci permet d'amliorer la productivit des concepteurs de circuits intgrs. 1.5.7 Diffrences entre un langage de programmation et VHDL VHDL nest pas un langage de programmation comme le C, cest un langage de description matriel. Il est important de bien comprendre la diffrence entre les deux : un langage de programmation est destin tre traduit en langage machine puis tre excut par un microprocesseur. un langage de description matriel comme VHDL dcrit une ralit matrielle, cest-dire le fonctionnement dun systme numrique. Il va tre traduit (synthtis) en un ensemble de circuits logiques combinatoires et squentiels qui vont tre implments dans un circuit intgr. Il ny a aucun microprocesseur pour excuter la description VHDL dans un circuit intgr. Des instructions telle que la boucle for peuvent se retrouver dans les deux langages, mais elles nont absolument pas le mme rle. 1.5.8 Bibliographie Le langage VHDL est un langage complexe dont les possibilits sont trs tendues. Si vous souhaitez approfondir vos connaissances sur ce sujet, les ouvrages suivants sont disponibles :

titre

auteur

diteur Eyrolles Dunod Mc Graw Hill


Doone Pubns

niveau dbutant Moyen avanc Dbutant avanc Dbutant avanc avanc

intrt * ** *** *** ***

VHDL : introduction la Philippe LARCHER synthse logique Le langage VHDL Fundamentals of digital logic with VHDL design HDL chip design Digital systems design with VHDL and synthesis Jacques WEBER Maurice MEAUDRE Stephen BROWN Zvonko VRANESIC Douglas J.SMITH K.C. CHANG

IEEE Computer Society

24

2 Logique combinatoire
2.1 Introduction, variables et fonctions logiques

Un circuit numrique est ralis partir dun assemblage hirarchique doprateurs logiques lmentaires ralisant des oprations simples sur des variables logiques. Ces variables logiques peuvent prendre les tats : (vrai, true) ou bien (faux, false,). Vous connaissez dj de nombreux systmes physiques qui travaillent partir de grandeurs ne pouvant prendre que deux tats: interrupteur ouvert ou ferm, lampe allume ou non, objet clair ou non, moteur en marche ou arrt, affirmation vraie ou fausse, grandeur physique suprieure ou infrieure un seuil fix. Par convention, on associe gnralement ltat vrai dune variable logique la valeur binaire 1 et la valeur 0 ltat faux. Cest la logique positive. On peut aussi faire le contraire (cest la logique ngative) en associant la valeur 0 ltat vrai et la valeur 1 ltat faux. Dans ce cours, on travaillera toujours en logique positive, sauf mention contraire. Electriquement, ltat vrai (ou la valeur 1) va tre associ un niveau de tension haut (la tension dalimentation du montage VDD en gnral) et ltat faux (valeur 0) va tre associ un niveau de tension bas (en gnral, la masse du montage GND). Les composants lmentaires du montage sont des paires de transistors MOS (logique CMOS) qui peuvent tre vus comme des interrupteurs ouverts ou ferms. En logique, tout raisonnement est dcompos en une suite de propositions lmentaires qui sont vraies ou fausses. Georges BOOLE, mathmaticien britannique (1815-1864) a cr une algbre qui codifie les rgles (algbre boolenne) laide de variables logiques ne pouvant prendre que deux tats et doprations lmentaires portant sur une ou 2 variables. Lalgbre de BOOLE ne traite que de la logique combinatoire, cest dire des circuits numriques dont la sortie ne dpend que de ltat prsent des entres (sans mmoire des tats passs). A chaque oprateur logique boolen (NON, ET, OU, NON ET, NON OU, OU exclusif, NON OU exclusif), on va associer un circuit numrique combinatoire lmentaire. La logique squentielle (avec mmoire) sera vue au chapitre suivant. 25

2.1.1 Les oprateurs fondamentaux 2.1.1.1 INV (NON) Loprateur dinversion ne porte que sur une seule variable dentre. Si A est la variable dentre, S la variable de sortie vaut : S = A (on prononce A barre). Le tableau suivant rsume laction de cet oprateur. Dans ce chapitre, linterrupteur ouvert vaut 0 et linterrupteur ferm vaut 1.

Table de vrit A 0 1

Montage
VDD

Symbole traditionnel

Symbole normalis

S=A
1 0
A S

2.1.1.2 AND (ET)

Loprateur AND (ET) porte sur deux variables dentre. Si A et B sont les variables dentre, alors S = A.B. S est vraie si A ET B sont vraies. Loprateur AND est symbolis par le point (.) comme la multiplication en mathmatique (cest dailleurs lopration ralise en binaire). On peut aussi voir cette fonction comme loprateur minimum (min) qui prend la plus petite des deux valeurs. Le tableau suivant rsume laction de cet oprateur.

Table de vrit A 0 0 1 1 B 0 1 0 1 S = A.B 0 0 0 1


A B

Montage
VDD

Symbole traditionnel

Symbole normalis

A B

&

26

2.1.1.3 OR (OU)

Loprateur OR (OU) porte sur deux variables dentre. Si A et B sont les variables dentre, alors S = A+B. S est vraie si A OU B sont vraies. Loprateur OR est symbolis par le plus (+) comme laddition en mathmatique. On peut voir cette fonction comme loprateur maximum (max) qui prend la plus grande des deux valeurs. Le tableau suivant rsume laction de cet oprateur.

Table de vrit A 0 0 1 1 B 0 1 0 1 S = A+B 0 1 1 1


A

Montage
VDD

Symbole traditionnel

Symbole normalis

B S

2.1.1.4 NAND (NON ET)

Loprateur NAND (NON ET) porte sur deux variables dentre. Si A et B sont les variables dentre, alors S = A.B . S est fausse si A ET B sont vraies. Loprateur NAND est linverse de loprateur AND. Son symbole est le symbole du ET suivi dune bulle qui matrialise linversion. Le tableau suivant rsume laction de cet oprateur.

Table de vrit A 0 0 1 1 B 0 1 0 1

Montage
VDD

Symbole traditionnel

Symbole normalis

S = A.B
1 1 1 0
A B S

&

27

2.1.1.5 NOR (NON OU)

Loprateur NOR (NON OU) porte sur deux variables dentre. Si A et B sont les variables dentre, alors S = A + B . S est fausse si A OU B sont vraies. Loprateur NOR est linverse de loprateur OR. Son symbole est le symbole du OU suivi dune bulle qui matrialise linversion. Le tableau suivant rsume laction de cet oprateur.

Table de vrit A 0 0 1 1 B 0 1 0 1 S=A+B 1 0 0 0


A

Montage
VDD

Symbole traditionnel

Symbole normalis

2.1.1.6 XOR (OU exclusif)

Loprateur XOR (OU exclusif) nest pas un oprateur de base car il peut tre ralis laide des portes prcdentes. Il porte sur deux variables dentre. Si A et B sont les variables dentre, alors S = A B = A. B + A.B . S est vraie si A est diffrent de B. Loprateur XOR est symbolis par un + entour dun cercle () car il ralise laddition en binaire, mais modulo 2. Le OU normal (inclusif) est vrai quand A et B sont vrai (1+1=1). Le OU exclusif exclut ce cas (do son nom). Le tableau suivant rsume laction de cet oprateur.

Table de vrit A 0 0 1 1 B 0 1 0 1
S = AB

Montage
VDD B
1 0 0 1

Symbole traditionnel

Symbole normalis

0 1 1 0

=1
S

28

2.1.1.7 XNOR (NON OU exclusif)

Loprateur XNOR (NON OU exclusif) nest pas non plus un oprateur de base. Il porte sur deux variables dentre. Si A et B sont les variables dentre, alors S = A B = A. B + A.B . S est vraie si A gale B. Loprateur XNOR est linverse de loprateur XOR. Son symbole est le symbole du XOR suivi dune bulle qui matrialise linversion. Le tableau suivant rsume laction de cet oprateur.

Table de vrit A 0 0 1 1 B 0 1 0 1
S= AB

Montage
VDD

Symbole traditionnel

Symbole normalis

1 0 0 1

B
1 0 0 1

=1

2.1.1.8 Portes universelles

Les NAND et les NOR sont des portes universelles car elles permettent de raliser toutes les oprations logiques lmentaires. Par exemple avec des NAND, on peut raliser les oprations : inversio n ET
B S A A S

OU
B

Le mme genre de montage peut tre ralis avec des portes NOR. On verra plus tard que les portes NAND et NOR demandent le minimum de transistors pour tre fabriques (4 transistors pour une NAND/NOR deux entres) et sont les plus rapides. 29

2.1.2 Algbre de BOOLE

Lalgbre de BOOLE porte sur des variables logiques (qui ne peuvent prendre que deux tats, vrai ou faux). Elle possde trois oprateurs boolens : NOT (NON), AND (ET), OR (OU). Lalgbre de BOOLE permet de raliser des fonctions laide de variables boolennes et des trois oprateurs de base. Le rsultat obtenu est boolen, cest--dire vrai ou faux.

Variables dentres

A B C
. . .

Fonction logique f

S = f(A, B, C, )

Les lois fondamentales de lalgbre de BOOLE se vrifient en crivant les tables de vrits et en testant tous les cas possibles. Ces lois sont les suivantes :

Commutativit Associativit Distributivit

A.B = B.A A+B = B+A A.(B.C) = (A.B).C A+(B+C) = (A+B)+C ET sur OU : A.(B+C) = (A.B) + (A.C) OU sur ET : A+(B.C) = (A+B) . (A+C) ET sur ET : A.(B.C) = (A.B) . (A.C) OU sur OU : A+(B+C) = (A+B) + (A+C)

Idempotence Complmentarit

A.A = A A+A = A

A.A = 0
A+A =1 1.A = A 1+A=1 0.A = 0 0+A = A

Identits remarquables

A partir de ces proprits, on dmontre les relations de base suivantes :

30

A.B + A. B = A
(A + B).( A + B ) = A

A + A.B = A

A.( A + B) = A A + A.B = A + B A.(A + B) = A.B Le OU exclusif a des proprits particulires. Il possde les proprits de commutativit et dassociativit, mais nest pas distributif par rapport au ET ou au OU. On a vu que :

A B = A.B + A.B
On a de plus
AB = AB = AB

et

1 A = A 0 A = A

Le thorme de DE MORGAN complte les proprits de lalgbre de BOOLE. Il est indpendant du nombre de variables. Il snonce des deux manires suivantes : 1) La ngation dun produit de variables est gale la somme des ngations des variables. Par exemple :
A.B = A + B

( A + B).( A. B) = ( A + B) + ( A. B)

31

2) La ngation dune somme de variables est gale au produit des ngations des variables. Par exemple :
A + B = A. B

( A + B) + ( A. B) = ( A + B).( A. B)

Dune manire plus gnrale, on peut dire que f(A, B, C, etc,+,.) = f(A, B, C , etc,.,+ )
2.1.3 Expression dune fonction logique

Il existe deux mthodes pour exprimer une fonction logique : soit donner directement son quation logique (par exemple, S = A + C + A.B.C ), soit utiliser une table de vrit. A un nombre fini N de variables dentre correspond 2N combinaisons possibles. La table de vrit va donc indiquer la valeur de la fonction pour les 2N valeurs possibles. Si par exemple S est une fonction de trois variables, il y aura 23 soit 8 combinaisons possibles. On va placer les trois variables dans un ordre arbitraire ( ne pas modifier ensuite !) A, B, C de gauche droite par exemple et crire les combinaisons dans lordre des entiers naturels (0, 1, 2, 3, , 2N-1). La table de vrit de S sera par exemple la suivante :

entres Valeur entire 0 1 2 3 4 5 6 7 A B C combinaison 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 A. B. C A. B.C A.B. C A.B.C A. B. C A. B.C A.B.C


A.B.C

Sorti e S 0 1 1 1 0 1 0 0

32

Sous sa forme complte, lquation logique de S se lit directement. Cest la somme du ET logique de chaque combinaison avec ltat de S correspondant. Ici, on obtient la forme canonique complte :

S = A. B. C .0 + A. B.C .1 + A.B.C .1 + A.B.C .1 + A.B. C .0 + A.B.C .1 + A.B.C .0 + A.B.C .0 On sait que 0.X = 0, donc on peut liminer les termes qui valent 0. Cela nous donne :

S = A. B.C .1 + A.B.C .1 + A.B.C .1 + A.B.C .1 On sait aussi que 1.X = X, donc on peut crire la forme canonique abrge : S = A.B.C + A.B.C + A.B.C + A. B.C Cest simplement la somme de combinaisons pour lesquelles S vaut 1. On la note aussi

(1,2,3,5) .
Nous avons maintenant un ensemble de rgles algbriques et nous savons exprimer une fonction logique. La question importante est : comment tre certain que lquation logique de la fonction est simplifie au maximum, cest--dire quelle va utiliser un nombre de portes minimum ?
2.1.4 Simplification des fonctions logiques

Lexpression dune fonction logique sous sa forme la plus simple nest pas quelque chose dvident. Trois mthodes sont utilisables : Le raisonnement. On cherche, partir du problme rsoudre, lexpression la plus simple possible. Evidemment, cette mthode ne garantit pas un rsultat optimal. La table de vrit et les proprits de lalgbre de BOOLE. Cest plus efficace, mais il est facile de rater une simplification, notamment quand la fonction est complique. La mthode graphique des tableaux de Karnaugh. Cest la mthode la plus efficace car elle garantit le bon rsultat. Cette mthode est utilise sous forme informatique dans tous les outils de CAO.

33

2.1.4.1 Simplification algbrique

Prenons un exemple. On a deux voyants A et B. On veut dclencher une alarme quand au moins un des deux voyants est allum, cest--dire : soit A allum avec B teint, soit B allum avec A teint, soit A et B allums. Par le raisonnement, le lecteur attentif aura trouv que S = A + B. Ecrivons la table de vrit :

A B S 0 0 0 0 1 1 1 0 1 1 1 1 On obtient donc : S = A.B + A B + AB Do on tire (daprs les proprits de lalgbre de BOOLE) :

S = A( B + B) + BA = A.1 + BA = A + BA = A + B

On voit bien que cette mthode de simplification devient peu vidente quand la fonction est plus complexe. Voyons maintenant une mthode plus efficace.
2.1.4.2 Simplification par les tableaux de Karnaugh

Cette mthode permet : davoir pratiquement lexpression logique la plus simple pour une fonction F. de voir si la fonction F nest pas plus simple (cela arrive). de trouver des termes communs pour un systme plusieurs sorties, dans le but de limiter le nombre de portes. de tenir compte de combinaisons de variables dentres qui ne sont jamais utilises. On peut alors mettre 0 ou 1 en sortie afin dobtenir lcriture la plus simple. de voir un OU exclusif cach.

34

A la main, on traite 4 variables sans difficults. Au maximum, on peut aller jusqu 5 voir 6 variables. En pratique, on utilise un programme informatique qui implmente gnralement lalgorithme de QUINE-McCLUSKEY, qui reprend la mthode de Karnaugh, mais de manire systmatique et non visuelle (et avec plus de 2 dimensions). Dfinition : dans un code adjacent, seul un bit change dune valeur la valeur suivante. Exemple avec deux variables :

Code binaire naturel A 0 0 1 1 B 0 1 0 1

Code GRAY A 0 0 1 1 B 0 1 1 0

Les tableaux de Karnaugh sont une variante des tables de vrit. Ils sont organiss de telle faon que les termes 1 (ou 0) adjacents soient systmatiquement regroups dans des cases voisines, donc faciles identifier visuellement. En effet, deux termes adjacents (qui ne diffrent que par une variable) peuvent se simplifier facilement : A.B.C + A.B.C = AB(C + C) = AB. On reprsente les valeurs de la fonction dans un tableau aussi carr que possible, dans lequel chaque ligne et chaque colonne correspondent une combinaison des variables dentre exprime avec un code adjacent (le code GRAY en gnral). Les traits gras correspondent une zone o la variable vaut 1. Avec de lhabitude, il est inutile dcrire les valeurs des variables, ces traits gras suffisent la lecture. Pour une criture rapide partir de la table de vrit, ou directement partir du cahier des charges, ou partir dune quation dj existante, on peut crire les variables A, B, C, D dans lordre ci contre. Cela permet une lecture systmatique.

D A B
35

La disposition des 1 et 0 dpend de lordre des variables et du code adjacent choisi, mais quelque soit lordre, lquation finale obtenue reste la mme. Pour la lecture et la simplification de lexpression, on cherche des paquets les plus gros possibles (de 1, 2, 4 ou 8 variables), en se rappelant que le code est aussi adjacent sur les bords (bord suprieur avec bord infrieur, bord gauche avec bord droit). On effectue une lecture par intersection en recherchant la ou les variables ne changeant pas pour le paquet. On ajoute alors les paquets. On obtient lexpression sous la forme dune somme de produit. Une case peut tre reprise dans plusieurs paquets. Exemple 1 : deux variables dentre A et B 1 case = produit de 2 variables, 2 cases = 1 variable, 4 cases = 1 ou 0.
B A 0 1 0 0 0 1 0 1 A 0 1 B 0 1 0 1 0 0 A 0 1 B 0 0 0 1 1 1 A 0 1 B 0 1 0 1 1 0

S = A.B

S = A.B

S=B

S=A

Exemple 2 : trois variables dentre A, B et C 1 case = produit de 3 variables, 2 cases = produit de 2 variables, 4 cases = 1 variable, 8 cases = 1 ou 0. Il y a parfois plusieurs solutions quivalentes.
B=1 00 0 1 0 0 01 0 1 C=1 S = A.B.C 11 0 0 10 0 0 A=1 A 0 1 B=1 00 1 1 01 0 0 C=1 S = B.C 11 0 0 10 0 0 A=1

BC A

BC

36

BC A 0 1 00 1 0 01 1 0 C=1 S=A 11 1 0

B=1 10 1 0 A=1 A

BC 00 0 1 0 0 01 0 0 C=1 S=B 11 1 1

B=1 10 1 1 A=1

BC A 0 1 00 0 0 01 0 1 C=1 11 1 0

B=1 10 1 1 A=1 A

BC 00 0 1 0 1 01 1 1 C=1 11 1 0

B=1 10 1 1 A=1

S = A.B+B.C+A.B.C

S = A.C+B.C+A.B

Exemple 3 : quatre variables dentre A, B, C et D 1 case = produit de 4 variables, 2 cases = produit de 3 variables, 4 cases = produit de 2 variables, 8 cases = 1 variable, 16 cases = 1 ou 0.
C 00 00 01 B 11 10 0 0 0 0 D S = A.B.C.D 0 0 0 A 0 10 1 0 D S = A.D 0 1 0 0 01 0 1 11 0 0 10 0 0 B 11 1 0 0 1 A AB 00 01 C 00 0 0 01 0 0 11 0 0 10 0 0

CD AB

CD

37

CD AB 00 01 B 11 10 0 0 1 1 D S = C.D 0 0 00 0 0 01 1 1 11 0 0

C 10 0 0 B 0 A 0 AB

CD 00 00 01 11 10 0 0 0 0 01 1 1 0 0 D 11 1 1 0 0

C 10 1 0 0 A 1

S = A.D+B.C.D

Dans une fonction logique, il peut exister des tats non utiliss. Ces combinaisons nont pas dimportance pour le problme rsoudre. On les appelle en anglais des tats dont care (ne pas tenir compte) et on les symbolise par un X. Ces tats X peuvent prendre la valeur la plus pratique pour simplifier la fonction. Exemple :
C 00 00 01 B 11 10 1 1 1 1 D 1 X 1 A X 10 1 1 D S=A 1 1 0 0 01 0 0 11 X 0 10 X 0 B 11 1 1 1 1 A AB 00 01 C 00 0 0 01 0 0 11 0 0 10 0 0

CD AB

CD

Il existe un cas particulier de fonction qui est parfois difficile dtecter, le OU exclusif (XOR) ou son complment. Il faut reprer des 1 disposs en quinconce. Pour voir sil sagit du XOR ou de son complment, il suffit alors de regarder la case toutes entres 0 . Si elle vaut 0, cest un XOR, sinon cest un XNOR. 38

B A 0 1 0 0 1 1 1 0 A

B 0 0 1 1 0 1 0 1

S = AB

S = AB

BC A 0 1 00 0 1 01 1 0 C S = ABC CD AB 00 01 B 11 10 0 1 1 0 D 00 0 1 01 1 0 11 0 1

B 10 1 0 A A

BC 00 0 1 1 0 01 0 1 C S = ABC C CD 10 1 0 B 1 A 0 AB 00 01 11 10 00 1 0 1 0 01 0 1 0 1 D 11 1 0

B 10 0 1 A

C 11 1 0 1 0 10 0 1 0 A 1

11 0 1 0 1

S = ABCD

S = ABCD

Il peut parfois tre plus pratique de lire les 0 dans le tableau plutt que les 1. On obtient alors

F = somme de produits ce qui implique (par DE MORGAN) que F = produit de somme des
variables inverses. Si par exemple on a :

39

BC A 0 1 00 1 1 01 1 1 C 11 0 1

B 10 0 0 A En comptant les 1 : S = B + A.C

En comptant les 0 au lieu des 1, on obtient : S = B.C + A.B . Do on tire : S = S = B.C + A.B

ce qui donne finalement : S = ( B + C).(A + B) . On peut utiliser la lecture directe sur les 0 quand il y a peu de 0 et beaucoup de 1.
2.2 Circuits logiques combinatoires

2.2.1 Circuits logiques fondamentaux

Il existe deux manires de dessiner ces oprateurs. La notation amricaine est la plus utilise (puisque les fabricants de composants sont souvent amricains) et donc la plus connue mais la notation normalise lavantage dtre plus facile dessiner avec une table traante. Dans ce cours, nous utiliserons uniquement la notation amricaine. Le tableau suivant rsume ce que nous avons dj vu. Ces circuits logiques existent avec 2, 3 voir 4 entres.

40

Les circuits logiques combinatoires sont des circuits constitus des portes ci-dessus fonctionnant simultanment et ralisant une ou plusieurs fonctions logiques.

Entres
. . .

Circuit logique combinatoire

. . .

Sorties

A une combinaison dentres (lentre) ne correspond quune seule combinaison de sorties (la sortie). La sortie apparat aprs application de l entre avec un certain retard qui est le temps de propagation dans la logique interne. Ce temps est dtermin par la technologie utilise, le nombre de portes traverses et la longueur des interconnections mtalliques. Les circuits combinatoires peuvent servir par exemple :

traduire des bits en chiffres reprsentant un nombre (ou des lettres ou un code particulier). On appelle ces circuits des codeurs (ou bien des dcodeurs pour lopration inverse). Par exemple, un codeur Gray ou bien BCD.

effectuer des oprations arithmtiques sur des nombres. Par exemple, un additionneur ou un multiplieur. transmettre ou recevoir des informations sur une ligne unique de transmission (une ligne srie), ce qui ncessite de transformer un nombre crit sous forme parallle en une suite de bits mis en srie et vice-versa. Cest le rle des circuits multiplexeur/dmultiplexeur. Voici par exemple une transformation srie/parallle suivie dune transformation parallle/srie : octets bits srie DEMUX traitement octets MUX bits srie

41

2.2.2 Le dmultiplexeur

Cest un circuit qui aiguille une entre vers une sortie dont on donne ladresse sous forme dun nombre cod en binaire.

Demux 2 vers 4

Y0 Y1 Y2 Y3

a1

a0

Le schma fondamental dun dmultiplexeur est :


G a1 a0

Y0

Y1

Y2

Y3

Sa table de vrit est gale :

N 0 1 2 3

a1 0 0 1 1

a0 0 1 0 1

Y0 = a 0 .a1 .G Y1 = a 0 .a1 .G Y2 = a 0 .a1 .G Y3 = a 0 .a1 .G

G 0 0 0

0 G 0 0

0 0 G 0

0 0 0 G

42

On obtient donc lquation suivante :

YK(N) = G si K = N YK(N) = 0 si K N

Si G est une donne, le circuit est un dmultiplexeur (un aiguillage divergent). Son utilisation premire est la conversion srie/parallle des donnes. Il peut aussi servir pour raliser des fonctions combinatoires. La limitation de ce type de circuit est le nombre dentres/sorties qui croit fortement avec le nombre de variables dadresse N. Il volue en N + 2N + 1.
2.2.3 Le dcodeur

Le dcodeur est de la mme famille que le dmultiplexeur, mais avec lentre G qui vaut 1 en permanence. On trouve alors en sortie un 1 parmi des 0.

Dcodeur 2 vers 4

Y0 = 0 Y1 = 0 Y2 = 1 Y3 = 0

a1=1 a0=0

On appelle aussi ce circuit un dcodeur dadresse utilis pour adresser les diffrentes lignes dune mmoire. Sa table de vrit est gale :

N 0 1 2 3

a1 0 0 1 1

a0 0 1 0 1

Y0 = a 0 .a 1

Y1 = a 0 .a 1

Y2 = a 0 .a 1

Y3 = a 0 .a1

1 0 0 0

0 1 0 0

0 0 1 0

0 0 0 1

43

On obtient donc lquation suivante :

YK(N) = 1 si K = N YK(N) = 0 si K N

Comme pour le dmultiplexeur, la limitation de ce type de circuit est le nombre dentres/sorties qui croit fortement avec le nombre de variables dadresse N.
2.2.4 Le multiplexeur

Le multiplexeur est la fonction inverse du dmultiplexeur. Cest un slecteur de donnes ou aiguillage convergent. Il peut transformer une information apparaissant sous forme de n bits en parallle en une information se prsentant sous forme de n bits en srie. La voie dentre, slectionne par son adresse, est relie la sortie.

I0 I1 I2 I3

Mux 4 vers 1

a1

a0

Le schma logique est le suivant :


a1 a0 I0 I1 I2 I3

44

Son quation de sortie est gale : Y = I 0 .a 1 .a 0 + I1 .a 1 .a 0 + I 2 .a 1 .a 0 + I 3 .a 1 .a 0 avec la table de vrit :

a1 0 1 2 3 0 0 1 1

a0 0 1 0 1

Y I0 I1 I2 I3

Un multiplexeur peut servir raliser des fonctions logiques quelconques. La limitation de ce type de circuit est toujours le nombre dentres/sorties qui croit fortement avec le nombre de variables dadresse N (de la mme manire que le dmultiplexeur).
2.2.5 Lencodeur de priorit

Lencodeur est la fonction inverse du dcodeur. On met sur les entres un 1 parmi des 0 et on obtient sur les sorties ladresse de lentre 1. La priorit ne sert que quand plusieurs entres sont 1 en mme temps. Le circuit donne alors ladresse de lentre dont le rang est le plus lev. Il y a donc priorit aux entres de rang le plus lev.

I0 = 0 I1 = 0 I2 = 1 I3 = 0

Encodeur de priorit

a1 = 1 a0 = 0

Sa table de vrit est gale :

I3 0 1 0 0 0

I2 0 X 1 0 0

I1 0 X X 1 0

I0 0 X X X 1

a1 0 1 1 0 0

a0 0 1 0 1 0

45

2.2.6 Les mmoires

Les PROM sont des mmoires mortes programmables. Le schma ci-dessous montre un exemple de PROM bipolaire fusible (procd osbolte depuis la fin des annes 1970).

1 DECODEUR D'ADRESSE 2

a1

a0 Y0 Y1 Y2 Y3

Ladresse applique sur les entres (a1 a0) provoque, via le dcodeur dadresses, la mise 1 de la ligne dadresse correspondante. Si le fusible existant entre cette ligne et la sortie Yn est intact, cette sortie vaut 1. Si le fusible a t claqu pendant la programmation, la sortie vaut 0 ( travers une rsistance de pull-down). La programmation est ralise avec un programmateur dEPROM, le fichier contenant la configuration pouvant tre au format JEDEC (Joint Electronics Design Engineering Council). Dans cet exemple, la PROM (4 mots de 4 bits) contient les donnes suivantes :

a1 0 0 1 1

a0 0 1 0 1

Y0 0 0 0 1

Y1 1 0 0 0

Y2 0 1 1 1

Y3 1 0 0 1

On nutilise plus de PROM pour raliser directement une fonction logique mais le principe, lui, demeure tout fait dactualit. Certains circuits, comme les circuits logiques programmables par exemple, utilisent en interne de mmoires pour raliser des fonctions logiques. 46

2.2.7 Buffer bidirectionnel 3 tats 2.2.7.1 La porte 3 tats

Un signal de commande peut tre ajout une porte logique afin de mettre sa sortie ltat haute impdance (la sortie est en lair). Par exemple, quand C = 0, les transistors de sortie sont tous ouverts et la sortie est flottante. Quand C = 1, la porte fonctionne normalement. Dans le cas dune NAND, cela donne le schma logique quivalent suivant :
A S B C B C A S

Quand la sortie S est ltat haute impdance, on dit quelle est ltat Z (ou HiZ).
2.2.7.2 Notion de bus

Une question fondamentale de llectronique numrique est : comment faire dialoguer plusieurs circuits intgrs numriques entre eux de la manire la plus efficace possible ? Deux solutions sont possibles : la liaison point point ou le bus. 1. La liaison point point. Pour chaque liaison, on tire une paire de fils, un fil qui envoie des donnes, lautre fil qui en reoit. On nutilise pas ltat Z dans ce cas. Chaque circuit tant reli indpendamment avec ses voisins, le nombre de fils augmente trs rapidement. Voici un exemple avec 4 circuits.

Circuit 1

Circuit 2

Circuit 3

Circuit 4

On peut compter 1 + 2 + 3 = 6 paires de fils pour assurer la liaison point point. Dans le cas gnral, avec N circuits, on a 1 + 2 + 3 + 4 + + N-2 + N-1 liaisons ce qui donne

N2 N paires de fils pour N circuits. On voit que si on veut transmettre 32 bits en mme 2
47

temps, il faut 32 paires par liaison et le nombre de fils tirer entre les circuits augmente comme 64 x (nombre de circuits)2. Cette solution nest pas valable sauf si on limite le nombre de circuits (5 ou 6 maximum) et le nombre de fils par paire (2 ou 4 au maximum). Mais le dbit devient alors trop faible moins daugmenter massivement la frquence de transfert. Cest pourtant la solution utilise aujourdhui en informatique. Dans les PC, on est pass en 10 ans dinterfaces parallles (port parallle, PATA, PCI,) des interfaces sries (USB, SATA, PCI Express, ). Pour cela, on a utilis des technologies de type rseau Ethernet avec deux apports fondamentaux : le switch (concentrateur) et une monte massive en dbit (2.5 Gbit/s en PCI-E 1.0). Le montage devient alors le suivant :

switch

Circuit 1

Circuit 2

Circuit 3

Circuit 4

Le nombre de paires de fils augmente maintenant linairement avec le nombre de circuits, car cest le switch qui connecte (intelligemment) les circuits qui veulent changer de linformation. Grce au dbit lev (200 Mo/s net par fil en PCI-E 1.0) sur plusieurs paires (1x, 2x, 4x, 8x, 16x ou 32x), les performances sont excellentes. Il y a bien videmment un problme dhorloge pour lire les donnes. En effet, il est impossible que tous les circuits partagent la mme horloge 2.5 GHz parfaitement en phase pour lire les donnes. La deuxime innovation qui se cache derrire PCI-E est le fait que chaque liaison srie (chaque fil) porte les informations dhorloge ncessaires au dcodage des donnes grce un code 8B/10B. Chaque rcepteur va pouvoir resynchroniser son horloge de dcodage sur le flux de donnes reu car chaque liaison 2.5 Gbit/s porte ses propres informations dhorloge. 2. Le bus. Dans ce cas, tous les circuits sont branchs simultanment sur le mme fil.

48

bus Circuit 1 Circuit 2

Circuit 3

Circuit 4

Tous les circuits ont la capacit de gnrer un tat sur le bus ou bien de lire une valeur. Pour que cela soit possible, il faut que chaque broche soit bidirectionnelle, cest--dire quelle fonctionne aussi bien en entre quen sortie. Il faut donc connecter en parallle un buffer dentre avec un buffer de sortie. Si on veut que lentre puisse lire une valeur envoye par un autre circuit, il faut obligatoirement que le buffer de sortie cesse de gnrer un niveau sur le fil. La solution consiste faire passer ce buffer ltat haute impdance. Lensemble forme un buffer bidirectionnel 3 tats.
bus Commande trois tats dout din Circuit 1 Circuit 2 Commande trois tats dout din

Commande trois tats dout din

Circuit 3

Circuit 4

Commande trois tats dout din

Quand un circuit veut envoyer un bit sur le bus, les autres circuits doivent mettre leur sortie ltat Z et lire la valeur. Si deux circuits essayent de gnrer un niveau oppos en mme temps, il y a conflit de bus et ltat devient indtermin. Il y a donc forcment un matre de bus (par exemple, un microprocesseur) indiquant qui a le droit de gnrer sur le bus et qui force les autres circuits passer ltat Z. En pratique, un bus est compos de N fils de mme nature. Un bus dadresses par exemple qui sera unidirectionnel ou encore 49

un bus de donnes qui sera lui bidirectionnel. Le bus de donnes est un bus parallle, la bande passante est partage entre les circuits. Le bus PCI est un exemple typique de bus parallle. Il a atteint la frquence de 66 MHz avec 64 bits de donnes, soit un dbit de 528 Mo/s partag entre toutes les cartes. La monte en frquence au-del des 100 MHz devenant problmatique, on a choisit PCI-Express pour le remplacer partir de 2005.
2.3 Caractristiques temporelles

Nous tudierons ici les diffrents temps que l'on trouve dans les circuits combinatoires.

Dans les notices du constructeur, les temps min ou max (selon le cas) sont donns pour le plus mauvais des circuits, et dans le cas le plus dfavorable ( temprature maximale et tension dalimentation minimale). Une tude faite avec ces temps fournit un montage fonctionnant dans 100% des cas. Les temps typiques sont moins contraignants mais ils ne reprsentent pas le cas le plus dfavorable. Ils peuvent tres utiliss mais avec un plus grand risque.
2.3.1 Caractristiques temporelles

Considrons une porte logique. Les temps de transition et de propagation sont dfinis de la manire suivante :

le temps de propagation est le retard entre les signaux dentre et de sortie. Il est caus par
le temps de traverse des transistors et des fils formant le circuit logique. Il en existe deux types : tPLH (la sortie passe de 0 1 low to high ) et tPHL (la sortie passe de 1 0 high to low ). En rgle gnral, ces deux temps sont aujourdhui gaux (en CMOS).

le temps de transition est le temps mis par une sortie pour changer dtat. Il est
gnralement pris entre 10 et 90 % du niveau maximum. Il en existe deux types : tTLH (la sortie passe de 0 1) et tTHL (la sortie passe de 1 0). Ce temps est trs dpendant de la charge (capacitive notamment) sur la sortie du circuit. En rgle gnral, ces deux temps sont aujourdhui identiques (en CMOS). Le dessin suivant en donne une illustration pour une porte non-inverseuse :

50

Entre

tTLH Sortie

tTHL
90 % 10 %

tPLH

tPHL

A l'entre dun circuit logique dpourvu dun dclencheur seuil (trigger de Schmitt), on doit respecter un temps de transition maximum (tmmax), sous peine de transitions parasites en sortie. Dans le cas de signaux temps de transitions trop longs ou prsentant des parasites, une porte pourvue dun trigger permet de mettre en forme ces signaux pour qu'ils puissent attaquer correctement la logique :

Vi

Vo

Vi

Seuil Haut Seuil bas

Vo

En sortie de circuit, les temps de transitions dpendent de la technologie employe mais pas du temps de monte du signal d'entre, tant que celui-ci reste infrieur 3 5 fois les temps de transitions usuels de cette technologie.
2.3.2 Etats transitoires

Le fonctionnement normal dune carte logique combinatoire ne peut tre dduit du fonctionnement des circuits qui la composent en supposant ces circuits idaux (temps de transition nuls, temps de propagation nuls). Dans ce paragraphe, nous allons proposer une

51

mthode danalyse des alas de commutation en tenant compte des temps de propagation. Pour cela, nous allons dfinir le modle asynchrone dun circuit combinatoire : avec : = sup(tPLH, tPHL) s(t) = s+(t - ) ou s(t + ) = s+(t)

a0 a1

s+(t) retard

s(t)

Il faut que la dure de limpulsion active sur lentre dun circuit combinatoire soit suprieure au retard pour que la sortie change dtat. Sinon, lnergie de limpulsion est insuffisante pour provoquer la commutation. Pour analyser le fonctionnement dun circuit combinatoire N entres et une sortie, on dtermine la table dexcitation du circuit. Cest un tableau de Karnaugh N+1 variables (les entres plus la sortie s) permettant de dterminer s+. Quand s+ est diffrent de s dans ce tableau (zone hachure), nous sommes en prsence dun rgime transitoire (s va changer aprs un temps ). Quand s+ est gal s (valeur encercle), nous sommes dans un tat stable (s reste dans le mme tat).
a1 a0 s 00 s+ 0 1 0 0
1

01 0 0
2

11 1 1
3

10 0 0
4

phases transitoires s+ s phases stables s+ = s

On se sert de cette table dexcitation pour tablir le chronogramme du circuit partir dune squence dentre quelconque (par exemple 0,0 ; 0,1 ; 1,1 ; 1,0) :

a0 a1 s 1 2 3 4

phases transitoires s+ s

52

Voici un exemple de prvision des alas de commutation. Soit le circuit suivant :


a b d
+

a.d d s=a.d+b.c

b.c c

Pour la mthode danalyse, toutes les portes sont retard nul et un retard nest ajout que sur linverseur. La table dexcitation de d+ en fonction de a, b, c, d est (d+ = b ) :

d d+

abc 0 1

000 001 011 010 110 111 101 100 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 phases transitoires phases stables

On en dduit la table de vrit de la sortie du circuit (en conservant la grille des phases transitoires/stables :

d S

abc 0 1

000 001 011 010 110 111 101 100 0 0 0 0 1 1 0 0 0 1 1 1 0 1 0 1 phases transitoires phases stables

Etudions maintenant la transition b = 1, 0, 1 avec a et c qui restent en permanence 1. On a alors lvolution suivante en sortie :

abc = 111

S=1

abc = 101 Phase transitoire : S = Ala de commutation 0 Etat final : S = 1. abc = 111 Phase transitoire : S = 1 Etat final : S = 1.
53

Pas dala

Sans utiliser cette mthode danalyse, on aurait trouv S = 1. En effet, cet ala de commutation napparat pas sur la table de vrit purement combinatoire de S. On nomme cette impulsion dont la dure ne dpend que du temps de propagation de linverseur, un glitch . Dans lanalyse prcdente, on a pris un temps de propagation nul pour les portes autres que linverseur afin de simplifier le calcul. Introduire un temps de propagation tp sur ces portes ne change rien au rsultat final comme nous le montre le chronogramme suivant. Lala est simplement dcal de 2.tp, mais sa dure reste gale .

a b c b.c d a.d S

tp

tp ala de commutation

tp

tp

tp

tp

Quand un circuit logique combinatoire a la possibilit de produire cet tat transitoire, on dit quil existe un hazard (que le glitch se produise ou non). Ces notions de glitch et de hazard ne sappliquent que pour des circuits logiques combinatoires purs, cest--dire sans rebouclage des sorties sur les entres. Deux types de hazard existent :

Hazard statique. Un hazard statique 1 est la possibilit pour un circuit de produire un


glitch 0 alors que la sortie aurait normalement du rester 1. Cest le cas dans lexemple prcdent. Un hazard statique 0 est la possibilit pour un circuit de produire un glitch 1 alors que la sortie aurait normalement du rester 0. 54

Hazard dynamique. Un hazard dynamique est la possibilit que la sortie dun circuit
change plus dune fois pour un seul changement logique sur une entre.

entre sortie De multiples transitions sur une sortie peuvent se produire sil y a plusieurs chemins logiques avec des retards diffrents entre lentre et la sortie qui changent. Il est important de noter que le hazard statique ou dynamique est born dans le temps par rapport au dernier changement sur les entres. Une fois que le chemin combinatoire qui traverse le plus de portes logiques (le chemin critique) a t travers, le signal est forcment stable en sortie. Le temps de traverse du chemin critique sappelle le temps critique. Le
signal en sortie du circuit combinatoire est stable temps critique aprs le dernier changement sur les entres. Il ne peut se produire aucun changement pass ce dlai.

Pour la conception de circuits logiques squentiels (avec rebouclage des sorties sur les entres), il faut utiliser des circuits logiques combinatoires sans hazards ( hazard-free circuits ). Il est possible dliminer les hazards dun circuit en utilisant la mthode danalyse vue prcdemment et en modifiant le tableau de karnaugh afin den liminer les tats transitoires. En effet, les phases transitoires du tableau de S peuvent tre modifies sans que cela influe sur ltat stable de S. Cela ne change S que pendant les transitions. Dans notre exemple, il suffit de changer ltat abcd = 1010 en passant S de 0 1 pour supprimer le glitch. abc 0 S 1

000 001 011 010 110 111 101 100 0 0 0 0 1 1 0 0 0 1 1 1


1

0 1

phases transitoires phases stables

Cela revient modifier lquation de S qui est maintenant S = a.d + b.c + a.c. La transition b = 1, 0, 1 avec a et c qui restent en permanence 1 ne peut plus provoquer dala de 55

commutation puisque S vaut 1 dans tous les cas. Le schma du circuit hazard-free est donc le suivant. La mthode marche, mais elle sera difficilement utilisable en pratique. a b d+ d

a.d

b.c c

s=a.d+b.c+a.c

Remarque : il est important de noter que pour une porte logique lmentaire, il ne peut y avoir de glitch en sortie si une seule de ses entres change la fois. Cest la mme chose pour une LUT de FPGA
2.4 Description en VHDL

2.4.1 Introduction Il existe deux langages de description matriel (HDL : Hardware Description Language), VHDL et Verilog HDL. Le langage VHDL est assez aride apprendre, verbeux et fortement typ (pas de mlange de types de donne sans fonction de conversion), cest un driv du langage ADA. Verilog HDL drive quand lui du langage C avec tous ses avantages (comme la concision) mais aussi tous ses inconvnients : il est notamment plus ambig que VHDL, cest--dire que certaines descriptions peuvent tre interprtes de plusieurs manires. Verilog est le langage de conception dASIC le plus utilis dans le monde sauf en Europe ou VHDL est aussi trs utilis. Pour les FPGA, cest VHDL qui est le plus utilis sauf par les ingnieurs de conception ASIC quand ils se mettent aux FPGA. Pour apprendre VHDL, nous allons utiliser la mthode des exemples comments. Nous allons reprendre les circuits logiques combinatoires vus prcdemment et voir leur description en VHDL. Nous introduirons les caractristiques du langage au fur et mesure de la description des circuits. Nous reverrons de plus toutes ces notions en travaux pratiques. Le langage VHDL nest pas sensible aux diffrences majuscules/minuscules (case insensitive).

56

2.4.2 Portes combinatoires


1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. entity GATE is 4. port(D1, D2, D3 : in std_logic; 5. Y1, Y2, Y3, Y4, Y5 : out std_logic); 6. end GATE; 7. architecture RTL of GATE is 8. signal tmp : std_logic; 9. begin 10. Y1 <= D1 nor D2; 11. Y2 <= not (D1 or D2 or D3); 12. Y3 <= D1 and D2 and not D3; 13. Y4 <= D1 xor (D2 xor D3); 14. tmp <= D1 xor D2; 15. Y5 <= tmp nand D3; 16.end RTL;

La ligne 1 dfinit lappel la librairie IEEE grce linstruction library


nom_de_la_librairie . La ligne 2 indique lutilisation de tous les lments

(fonctions, composants ou type comme std_logic) du package std_logic_1164 grce linstruction use nom_de_la_librairie.nom_du_package.all .

Lignes 3 6 : dfinition des entres-sorties du design GATE dans lentit. Le mot cl port
annonce la liste des signaux dinterface. 4 modes sont possibles pour ces entres-sorties: IN, OUT, INOUT, BUFFER.

OUT

IN

INOUT

BUFFER

En VHDL, un signal dclar en sortie (OUT) ne peut pas tre lu dans larchitecture, mme pour un test dans une condition. Il faut le dclarer en BUFFER, ce qui correspond une sortie dont on peut lire la valeur dans larchitecture. On peut se passer du mode

57

BUFFER en utilisant un signal temporaire interne, puis en le copiant sur la sortie OUT. En pratique, le mode BUFFER nest jamais utilis. Dans lentit, les types des signaux peuvent tre les suivants : Types prdfinis : integer, natural (entier >= 0), positive (entier > 0), bit, bit_vector, boolean, real, time, std_logic, std_logic_vector. Exemples :
NUM : in integer range -128 to 127; NUM1 : in integer; DATA1 : in bit_vector(15 downto 0);

(128 < NUM < +127) (231 < NUM1 < +231 - 1) (DATA1 : bus 16 bits)

DATA2 : out std_logic_vector(7 downto 0); (DATA2 : bus 8 bits)

Types dfinis par lutilisateur : Les types numrs. Exemples :


type ETAT is (UN, DEUX, TROIS); TOTO : out ETAT;

Les tableaux. Exemples :


Type TAB8x8 is array (0 to 7) of std_logic_vector(7 downto 0); tableau : out TAB8x8;

Les sous-types. Exemples :


subtype OCTET is bit_vector(7 downto 0); BUS : inout OCTET;

Lignes 7 16 : la partie dclarative de larchitecture (entre les mots cls architecture et


begin) est destine la dclaration des objets internes (les E/S sont dclares dans lentit) utiliss dans cette architecture. Ces objets sont gnralement des signaux, constantes, variables ou alias. Les signaux. Ils reprsentent les fils dinterconnexion sur la carte. Exemple :
signal BUS : std_logic_vector(15 downto 0);

58

Les constantes. Une constante peut tre assimile un signal interne ayant une valeur fixe. Exemples :
constant ZERO : bit_vector(7 downto 0); constant HIZ : std_logic_vector(15 downto 0);

Les variables. Une variable est un objet capable de retenir une valeur pendant une dure limite. Ce nest pas une liaison physique, mais un objet abstrait qui doit tre interprt par le synthtiseur. Elle ne doit tre utilise qu lintrieur dun process. Exemple :
variable TEMP : integer;

Les alias. Ils permettent de nommer un objet de diffrentes manires. Exemples :


signal DBUS : bit_vector(15 downto 0); alias OCTET0 : bit_vector(7 downto 0) is DBUS(7 downto 0);

La ligne 8 dfinit donc un signal temporaire tmp de type std_logic. Le corps de lachitecture (lignes 9 16) contient la description du design. VHDL reconnat les oprateurs logiques suivant : and, nand, or, nor, xor, xnor et not. Leur signification est vidente. Il faut juste faire attention leur associativit. Il est possible dcrire :
X <= A and B and C; puisque le and est associatif (A . B . C = A . (B . C))

Loprateur daffectation (ou dassignation) <= permet daffecter une valeur un signal. Par contre, on na pas le droit dcrire :

X <= A nor B nor C; puisque le nor nest pas associatif ( A + B + C A + ( B + C ) )

Il faut obligatoirement mettre des parenthses pour indiquer ce que lon souhaite raliser.

X <= A nor (B nor C);

Pour faire un vrai nor 3 entres, il suffit dcrire (car le or est associatif) :

X <= not (A or B or C);

59

Compte tenu de ce qui prcde, on voit que le circuit GATE ralise les fonctions logiques suivantes :

Y1

D1

Y2

D2

Y3

D3

Y4

Y5 tmp

2.4.3 Multiplexeurs (mmorisation implicite)


1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. entity MUX is 4. port(Sel : in std_logic_vector(1 downto 0) ; 5. A, B, C, D : in std_logic; 6. Y1, Y2, Y3, Y4 : out std_logic); 7. end MUX; 8. architecture RTL of MUX is 9. signal tmp : std_logic ; 10.begin 11. 12. 13. Y1 <= A when Sel(0) = '0' else B; p0 : process (A, B, Sel) begin

60

14. 15. 16. 17. 18. 19. 20. 21. 22.

if (Sel(0) = '0') then Y2 <= A; else Y2 <= B; end if; if (Sel(1) = '1') then Y3 <= A; end if; end process;

23. p1 : process (A, B, C, D, Sel) 24. begin 25. case Sel is 26. when "00" => Y4 <= A; 27. when "01" => Y4 <= B; 28. when "10" => Y4 <= C; 29. when "11" => Y4 <= D; 30. when others => Y4 <= A; 31. end case; 32. end process; 33.end RTL;

Les constantes littrales dsignent des valeurs numriques, des caractres ou des valeurs binaires. Les constantes numriques sont de type entier ou flottant et peuvent exprimer une valeur dans une base comprise entre 2 et 16. La lettre E (ou e), pour exposant, est accepte pour les entiers et pour les flottants. La base par dfaut est 10. Exemples de constantes littrales:

14 14.0 2#1010#

0 0.0 16#A#

1E4 1.0e4 8#12#

123_456 123.456 10

Entiers en base 10 Flottants en base 10 Le nombre 10

'A' "coucou"

'B'

'5'

';' "- +"

Des caractres Des chaines de caractres

"01234" "un essai"

'1' "1010" X"ff"

'0' B"1010" O"56"

Des bits seuls Une chaine binaire en base 2 Une chaine binaire en base16 et 8

61

Lignes 8 33. Les oprateurs relationnels suivants sont prsents dans les instructions
conditionnelles de VHDL telles que whenelse , ifthenelse ou case : =, /=, <, <=, >, >=. Ils retournent un rsultat boolen (vrai/faux). Exemple :

if (a > b) then

Faites attention ne pas confondre laffectation X <= Y; avec loprateur relationnel infrieur ou gal. Les oprateurs relationnels peuvent tre combins aux oprateurs logiques de la manire suivante :

if (a <= b and b=c) then

Loprateur de concatnation & permet de juxtaposer deux objets de type std_logic ou std_logic_vector. Exemples :
signal octet1, octet2 : std_logic_vector(7 downto 0) ; signal mot1, mot2 : std_logic_vector(15 downto 0) ; mot1 <= octet1&octet2 ; mot2 <= "100"&octet1(3 downto 0)&octet2&'1' ;

Il permet de simplifier lcriture de :


if (A = '1' and B = '0') then

en crivant :
if (A&B = "10") then

La ligne 11 dcrit un multiplexeur 2 entres avec lassignation conditionnelle when.

Y1 <= A when Sel(0) = '0' else B;

-- Sel(0) est le bit 0 de Sel

En effet, la phrase Y1 prend la valeur de A si Sel(0) est gal 0 sinon (Y1 prend la valeur de) B dcrit bien un multiplexeur deux entres A et B vers une sortie Y1 avec une entre de slection relie au bit de poids faible de Sel. La condition teste doit tre boolenne, ce qui est bien le cas puisque les oprateurs relationnels fournissent un rsultat boolen. 62

Lignes 12 32 : fonctionnement concurrent et squentiel. En lectronique, les composants


fonctionnent simultanment (fonctionnement parallle ou concurrent) alors quen programmation traditionnelle, les instructions sexcutent les unes la suite des autres de faon squentielle. Les deux modes de fonctionnement coexistent dans VHDL suivant que le code se trouve hors dun processus (fonctionnement concurrent) ou dans un processus (fonctionnement squentiel, avec des restrictions). Prenons par exemple :

A <= B; B <= C;

En programmation traditionnelle, la squence signifierait A prend la valeur de B, puis B prend la valeur de C . A la fin du programme, A et B ont des valeurs diffrentes. Si on change lordre des instructions, la signification change. Cest le fonctionnement squentiel. En VHDL, il faut comprendre : tout moment, A prend la valeur de B et tout moment, B prend la valeur de C. En clair A, B et C ont tout le temps la mme valeur quel que soit lordre des instructions. Cest le fonctionnement concurrent. Voyons maintenant ce quest un processus. Cest un groupe dlimit dinstructions dot de trois caractristiques : 1. Le processus sexcute chaque changement dtat dun des signaux auxquels il est dclar sensible. 2. Les instructions dans le processus sexcutent squentiellement. 3. Les modifications apportes aux valeurs des signaux par les instructions daffectation prennent effet simultanment la fin du processus. Cest une restriction trs importante et il faut voir le 2.4.4 pour saisir pleinement ce que signifie squentiel en VHDL. La structure dun processus est la suivante :

Nom_de_processus : process(liste_de_sensibilit)

-- dclaration des variables locales du processus


begin

-- corps du processus
end process Nom_de_processus ;

63

Ligne 12 : le processus p0 se dclenche sur chaque changement dtat des signaux A, B et Sel. Ligne 13 18 : on dcrit nouveau un multiplexeur 2 entres avec lassignation conditionnelle if then else . En effet, la phrase si Sel(0) est gal 0, Y2 prend la valeur de A sinon Y2 prend la valeur de B dcrit bien un multiplexeur deux entres A et B vers une sortie Y2 avec une entre de slection relie au bit de poids faible de Sel. Ligne 23 : le processus p1 se dclenche sur chaque changement dtat des signaux A, B, C, D et Sel. Lignes 25 31 : on dcrit un multiplexeur 4 entres avec lassignation slective
case.

Ligne 25 : le slecteur est le bus Sel, de largeur 2 bits. Ligne 26 : Quand Sel vaut 00, Y4 prend la valeur de A, Ligne 27 : Quand Sel vaut 01, Y4 prend la valeur de B, Ligne 28 : Quand Sel vaut 10, Y4 prend la valeur de C, Ligne 29 : Quand Sel vaut 11, Y4 prend la valeur de D, Ligne 30 : pour toutes les autres valeurs de Sel (noubliez pas que Sel est un std_logic_vector dont chaque bit peut prendre 9 tats), Y4 prend la valeur de A. Cest la valeur par dfaut qui est obligatoire. On verra un peu plus loin que cela permet dviter dinfrer (de gnrer) un latch. On a bien dcrit un multiplexeur 4 entres A, B, C, D, une sortie Y4 et deux bits de slection Sel.

Nous allons maintenant lister les instructions squentielles qui doivent se trouver obligatoirement lintrieur dun processus et les instructions concurrentes qui doivent obligatoirement se trouver lextrieur dun processus.

64

Instructions en mode concurrent (hors process).


Assignation inconditionnelle. Forme gnrale : signal <= expression;.

A <= B and C; -- A prend la valeur du rsultat de lopration (B and C). X <= '0';

-- X prend la valeur 0.

Assignation conditionnelle. Forme gnrale : signal <= expression when


condition else expression;.

Y1 <= A when Sel(0) = '0' else B; -- Y1 prend la valeur de A si Sel(0) gal

0 sinon (Y1 prend la valeur de) B.


Assignation slective. Forme gnrale : with selecteur select signal <=
{expression when valeur_selecteur,};.

With ETAT select X <= A when "00", -- X prend la valeur de A si le signal ETAT, utilis comme B when "01", -- slecteur, vaut 00, B si ETAT vaut 01, etc. C when "10", D when others; -- tous les choix sont couverts

Instanciation

de

composant.

Forme

gnrale :

nom_instance :

nom_

composant port map (liste_ entre_sortie_composant);.

U0 : XOR4 port map (A, B, C, D, S); -- on insre le composant

XOR4 dans le design ( la manire dun symbole dans un schma). U0 est le nom dinstance. A, B, C, D sont les entres de U0, S est sa sortie.
Instruction generate. Cette instruction permet de gnrer plusieurs rpliques dun

composant ou dune quation laide dun for. Exemple, un additionneur 8 bits construit partir de 8 additionneurs 1 bit (composant FullAdder).

65

AN-1 A

BN-1 B

A1 A

B1 B

A0 A

B0 B

FullAdder CO CO S SN-1 CI

FullAdder CO S S1 CI

FullAdder CO S S0 CI CI

gen : for j in 7 downto 0 generate -- pour j allant de 7 0 genlsb : if j = 0 generate -- gnration de ladditionneur du bit de poids faible fa0 : FullAdder port map (A => A(0), B => B(0), CI => CI, S => S(0), COUT => end generate; genmid : if (j>0) and (j<7) generate -- gnration des autres additionneurs fax : FullAdder port map (A => A(j), B => B(j), CI => C(j), S => S(j), COUT => C(j+1)); end generate; genmsb : if j = 7 generate -- gnration de ladditionneur du bit de poids fort fa7 : FullAdder port map (A => A(j), B => B(j), CI => C(j), S => S(j), COUT => COUT); end generate; end generate; C(1));

Instructions en mode squentiel (dans un process).


Assignation inconditionnelle de signal. Forme gnrale : signal <= expression;.

A <= B and C; -- A va prendre la valeur du rsultat de lopration (B and C)

la fin du processus.
X <= '0'; -- X prend la valeur 0 la fin du processus.

Assignation inconditionnelle de variable. Forme gnrale : var := expression;.

V := '0'; -- X prend la valeur 0 immdiatement.

66

Assignation conditionnelle de signal ou de variable.

if (Sel(0) = '0') then -- si Sel(0) est gal 0, Y2 prend la valeur de A Y2 <= A; else -- sinon Y2 prend la valeur de B Y2 <= B; end if; -- branches incompltes possibles

Assignation slective.

case Sel is when "00" => Y4 <= A; -- si Sel vaut 00, Y4 prend la valeur de A when "01" => Y4 <= B; -- si Sel vaut 01, Y4 prend la valeur de B when "10" => Y4 <= C; -- si Sel vaut 10, Y4 prend la valeur de C when "11" => Y4 <= D; -- si Sel vaut 11, Y4 prend la valeur de D when others => Y4 <= A; -- pour toute autre valeur de Sel, Y4 gal A end case; -- branches incompltes possibles

Boucles.

for i in 0 to 7 loop -- pour i allant de 0 7 datari(i) <= "000"&datar(i); -- datari(i) = "000" concatn avec datar(i) end loop;

Lignes 19 21 : en VHDL, les signaux ont une valeur courante et une valeur prochaine
dtermine par loprateur dassignation. Si, lors dune instruction conditionnelle (concurrente ou squentielle), un signal reoit une assignation dans une branche alors il doit recevoir une assignation dans toutes les autres branches. Si tel nest pas le cas, chaque absence dassignation signifie que la prochaine valeur est identique la valeur courante et le synthtiseur doit gnrer une logique de mmorisation (bascule D ou latch). Dans notre exemple, si Sel(1) vaut 1, Y3 prend la valeur de A et sinon, Y3 garde sa valeur courante. Le synthtiseur infre donc un latch au lieu dun multiplexeur. Cest la mmorisation
implicite.

67

Il faut noter ici un point important : la mmorisation implicte nest possible qu lintrieur dun process. En effet, les instructions conditionnelles hors process (when, with select) ne peuvent tre incompltes dun point de vue syntaxique. Seuls le if et le case autorisent les branches incompltes, donc obligatoirement dans un process.

Le circuit MUX ralise donc les fonctions logiques suivantes :

Y1

B Y2

C Y3 D

Sel[1:0]

Y4

Sel[0] Sel[1]

2.4.4 Assignation inconditionnelle de signal : squentiel contre concurrent Le design suivant tente dclaircir un point parfois un peu obscur, cest--dire la diffrence de comportement des assignations inconditionnelles de signal entre le mode squentiel (dans le process) et le mode concurrent (hors process).
1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. entity conc_seq is 4. port( A, B : in std_logic; 5. Yconc : out std_logic; 6. Yseq : out std_logic); 7. end conc_seq;

68

8. architecture a1 of conc_seq is 9. begin 10. Yconc <= A; 11. Yconc <= B; 12. process(A, B) begin 13. Yseq <= A; 14. Yseq <= B; 15. end process; 16.end a1 ;

En mode concurrent, les deux fils A et B sont relis ensemble sur Yconc. Quand A et B sont dans un tat diffrent (01 ou 10), Yconc passe ltat indtermin X puisquil y a conflit entre A et B. Cest le fonctionnement lectronique traditionnel.

Etats X En mode squentiel, A et B sont copis dans Yseq. Mais il ny a pas de conflit, car comme nous sommes en squentiel, cest la dernire assignation qui est prise en compte (Yseq <= B). Il faut comprendre quavec des signaux (ce nest pas vrai pour des variables), toutes les assignations sont prpares dans le process, puis excutes en mme temps en sortant du process. Sil y a plusieurs assignations sur un mme signal (Yseq dans notre cas), elles sont toutes excutes, mais cest la dernire qui est prise en compte. Cest en ce sens que lxecution est squentielle.

2.4.5 Dmultiplexeur - dcodeur


1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. entity Demux_1vers8 is 4. port (G : in std_logic; 5. A : in std_logic_vector(2 downto 0); 6. Y : out std_logic_vector(7 downto 0) ); 7. end Demux_1vers8; 8. architecture a1 of Demux_1vers8 is 9. begin 10. PROCESS (G, A) BEGIN 11. if (G = '0') then 12. Y <= (others => '0'); 13. else

69

14. case A is 15. when "000" => Y <= "00000001"; 16. when "001" => Y <= "00000010"; 17. when "010" => Y <= "00000100"; 18. when "011" => Y <= "00001000"; 19. when "100" => Y <= "00010000"; 20. when "101" => Y <= "00100000"; 21. when "110" => Y <= "01000000"; 22. when "111" => Y <= "10000000"; 23. when others => Y <= "00000001"; 24. end case; 25. end if; 26. END PROCESS; 27. end;

Le fonctionnement est le suivant : si G = 0, Y est mis 0. Lexpression (others => '0') est un agrgat. La mme valeur 0 est affecte tous les bits de Y. Si G = 1, Y(A) = 1. On obtient bien le dmultiplexeur du 2.2.2 dans sa version 1 vers 8 (3 bits dadresses). Il connecte G sur la sortie Y(A), A pouvant aller de 0 7.
Y0 Y1 Y2 Y3 Y4 Y5 Y6 Y7

Demux 1 vers 8

a2 a1 a 0

Pour raliser un dcodeur, il suffit de mettre G 1 en permanence au moment de lutilisation du composant. Le chronogramme suivant montre le fonctionnement du circuit :

70

Le problme avec linstruction case, cest quil faut autant de lignes que de sorties pour dcrire le fonctionnement du circuit. On peut rcrire le dmultiplexeur dune manire plus gnrale, c'est--dire indpendamment de sa taille, de la manire suivante :
1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. use IEEE.std_logic_unsigned.all; 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. entity Demux_1vers8 is port (G : in std_logic; A : in std_logic_vector(2 downto 0); Y : out std_logic_vector(7 downto 0) ); end Demux_1vers8; architecture a1 of Demux_1vers8 is begin PROCESS (G, A) BEGIN Y <= (others => '0'); -- forcment en premier if (G = '1') then Y(CONV_INTEGER(A)) <= '1'; end if; END PROCESS; end;

Y est mis 0 en premier. Si G = 0, Y reste 0. Si G = 1, on copie 1 sur le bit A de Y. Comme nous sommes dans un process, il ny a pas de conflit sur le bit A mis 1 car cest la dernire instruction qui est prise en compte (mode squentiel). Le problme avec cette description est que lindice du bit dans Y doit tre de type entier alors que A est de type
std_logic_vector. Il faut donc utiliser une fonction de conversion dfinie dans le

package std_logic_unsigned, CONV_INTEGER. La conversion du std_logic_vector en entier est obligatoire. Le fonctionnement du nouveau dmultiplexeur est strictement identique celui utilisant linstruction case (ainsi dailleurs que le nombre de portes utilises). Il faut aussi noter que les instructions :
if (G = '1') then Y(CONV_INTEGER(A)) <= '1'; end if;

peuvent tre remplaces par :


Y(CONV_INTEGER(A)) <= G;

2.4.6 Encodeur de priorit


1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. use IEEE.std_logic_arith.all; 4. entity Priority_encoder_8vers3 is 5. port (DataIn : in std_logic_vector(7 downto 0); 6. DataOut : out std_logic_vector(2 downto 0) ); 7. end Priority_encoder_8vers3;

71

8. architecture a1 of Priority_encoder_8vers3 is 9. begin 10. PROCESS (DataIn) BEGIN 11. DataOut <= (others => '0'); 12. Search : for I in DataIn'range loop 13. if DataIn(I) = '1' then 14. DataOut <= CONV_STD_LOGIC_VECTOR(I,3); 15. exit Search; 16. end if; 17. end loop Search; 18. END PROCESS; 19. end;

La description de cet encodeur de priorit est indpendante de sa taille, grce lutilisation dune boucle for. Lencodeur ralis est un 3 vers 8 tel que nous lavons dcrit au 2.2.5. Il donne en sortie ladresse de lentre de rang le plus lev valant 1. Dans lexemple suivant, I5 est lentre 1 de rang le plus lev. On trouvera donc 5 sur les sorties ai.

I7 = 0 I6 = 0 I5 = 1 I4 = 0 I3 = 0 I2 = 0 I1 = 1 I0 = 0

Encodeur de priorit

a2 = 1 a1 = 0 a0 = 1

DataOut est mis 0 en premier. Comme dans le dmultiplexeur, on sappuie sur le

fonctionnement squentiel du process pour raliser une description compacte. Etudions la boucle for. Il existe en VHDL des informations complmentaires attaches chaque objet dclar : ce sont les attributs. Dans ce langage, on dit que les attributs dcorent les objets auxquels ils sont rattachs. La rfrence un attribut se fait par le nom de lobjet en prfixe suivi du nom de lattribut en suffixe : objet'attribut. Il ne faut jamais oublier que VHDL est un langage orient objet comme ADA dont il est driv. Il existe des attributs prdfinis et des attributs dfinis par lutilisateur. Nous les verrons au fur et mesure de lavancement du cours. Lattribut range dfinit la plage de variation de lindice de lobjet. Dans notre exemple, DataIn'range est gal 7 downto 0 cause de la dclaration la ligne 6 :
port (DataIn : in std_logic_vector(7 downto 0);

72

Donc la boucle for (de la ligne 12 la ligne 17) va faire 8 tours (pour I = 7, 6, 5, 4, 3, 2, 1, 0). Search est ltiquette de la boucle. Dans cette boucle, on teste la valeur du bit I de
DataIn. Sil vaut 1, alors on copie la valeur de I dans DataOut puis on sort

immdiatement de la boucle for (instruction exit Search;).

12. 13. 14. 15. 16. 17.

Search : for I in DataIn'range loop if DataIn(I) = '1' then DataOut <= CONV_STD_LOGIC_VECTOR(I,3); exit Search; end if; end loop Search;

Le problme avec cette description est que I est de type entier alors que DataOut est de type
std_logic_vector. Il faut donc utiliser une fonction de conversion dfinie dans le

package

std_logic_arith, CONV_STD_LOGIC_VECTOR.

La

conversion

entier vers

std_logic_vector est obligatoire. Le chronogramme suivant montre le fonctionnement

du circuit :

2.4.7 Mmoire ROM


1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. use IEEE.std_logic_unsigned.all; 4. entity mem is 5. port (addr : in std_logic_vector(3 downto 0); 6. dout : out std_logic_vector(7 downto 0)); 7. end mem; 8. architecture a1 of mem is 9. TYPE mem_data IS ARRAY (0 TO 15) OF std_logic_vector(7 DOWNTO 0); 10. constant data : mem_data := ( 11. ("01000000"), 12. ("01111001"), 13. ("00100100"), 14. ("00110000"), 15. ("00011001"), 16. ("00010010"), 17. ("00000010"), 18. ("01111000"), 19. ("00000000"), 20. ("00010000"), 21. ("00000000"),

73

22. ("00000000"), 23. ("00000000"), 24. ("00000000"), 25. ("00000000"), 26. ("00000000")); 27.begin 28. dout <= data(CONV_INTEGER(addr)); 29.end;

Le type mem_data dfinit un tableau (ARRAY) de 16 cases de largeur 8 bits. La constante


data qui reprsente le contenu de la mmoire est initialise aux lignes 10 26. La ligne 29

dfinit le fonctionnement de la mmoire. Elle utilise une fonction de conversion dfinie dans le package std_logic_unsigned, CONV_INTEGER. En effet, lindex du tableau data doit tre un nombre entier alors que le signal data est de type std_logic_vector. La conversion
std_logic_vector vers entier est obligatoire. Le chronogramme suivant montre le

fonctionnement de la mmoire :

2.4.8 buffer bidirectionnel trois tats


1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. entity trois_etats is 4. port(E : in std_logic; 5. S : out std_logic; 6. Cde : in std_logic); 7. end trois_etats; 8. architecture comporte of trois_etats is 9. begin 10. S <= E when Cde='1' else 'Z'; 11. end comporte ;

Un buffer trois tats ressemble fortement un multiplexeur dans sa description :


S <= E when Cde='1' else 'Z';

Il faut traduire par : S prend la valeur de E si Cde est gal 1 sinon S prend la valeur Z, ce qui est bien la description dun buffer trois tat.

74

Le chronogramme suivant montre lvolution des signaux :

Etat Z

Un buffer bidirectionnel est un buffer trois tats dont la sortie est rinjecte dans le design :
1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. entity bidir is 4. port(E : in std_logic; 5. S : out std_logic; 6. IO : inout std_logic; 7. Cde : in std_logic); 8. end bidir; 9. architecture comporte of bidir is 10. begin 11. IO <= E when Cde='1' else 'Z'; 12. S <= IO; 13. end comporte ;

IO est maintenant bidirectionnelle ( la fois entre et sortie). Si Cde = 1, IO est une sortie, si Cde = 0 alors le buffer 3 tats passe ltat haute impdance et on peut utiliser IO comme une entre. Pour pouvoir crire une valeur depuis lextrieur sur IO, il faut que Cde soit gale 0. Une broche bidirectionnelle est utilise par exemple pour lire et crire des donnes dans une mmoire de type RAM. Pour simuler correctement un buffer bidirectionnel, il faut crer un composant externe afin de gnrer un tat sur IO quand ce signal est une entre.

Composant externe

bidir

75

Le chronogramme suivant montre lvolution des signaux en signalant la valeur impose sur IO depuis lextrieur : Etat Z

IOext = Z

IOext = 1

IOext = 0

IOext = Z

Lorsque le buffer trois tats nest pas ltat Z (Cde = 1), il faut que le composant connect sur IO depuis lextrieur impose un tat haute impdance sur cette broche. Sinon, il y aura un conflit de bus.
2.5 Exercices

Exercice 2.1 1 Rappeler la table de vrit des portes fondamentales OR, AND, NOR, NAND, XOR, XNOR. 2 Exprimer par une fonction logique que :

Les variables A, B, C et D sont toutes gales 1. Toutes les variables A, B, C et D sont nulles. Au moins lune des variables A, B, C, D est gale 1. Au moins lune des variables A, B, C, D est gale 0. Les variables A, B, C et D prennent les valeurs 0,1,1,0.
3 Simplifier les fonctions logiques suivantes : F1 = (A + B). C + A + B.C F2 = A.C + B. C + A.B F3 = A.B + A. B F4 = A + B + A. B 4 Dmontrer les relations suivantes : A.B + A. B = A
(A + B).( A + B) = A
A + A.B = A

76

A.( A + B) = A
A + A.B = A + B A.(A + B) = A.B
AB = AB = AB 1 A = A

0 A = A

5 Montrer que A.C + B.C = A.C + B. C . 6 Calculer les complments de : (A + B).( A + B) (A + B + C).(B + C + D).(A + C + D) A. B.C + A.B. C + A.(B.C + B. C) 7 Raliser un circuit logique ayant deux entres A et B, une sortie S et respectant le chronogramme suivant :
A t B t S t

8 Donner le schma logique avec des porte OR, AND et NOT permettant de raliser la fonction logique : F = A.C + B.D Exercice 2.2 Considrons le circuit ci-dessous :

77

A B

F S0 S1 C

Ce circuit ralise la fonction F qui peut tre contrle par les variables logiques S0, S1 et C. On veut analyser la variation de F en fonction des valeurs de S0, S1 et C et lexprimer en fonction de A et B. 1. Etablir la forme gnrale de F en fonction des variables A, B, C, S0, S1. On appliquera le thorme de DE MORGAN pour obtenir F sous forme dune somme de produits. 2. En dduire la table de vrit de F en fonction de S0, S1 et C. 3. En dduire enfin les valeurs respectives de S0, S1 et C pour que la fonction F reprsente
A.B , A.B , A B , A B .

Exercice 2.3 On dsire raliser un gnrateur de parit P bas sur le principe suivant. P vaut 1 quand dans un mot de 4 bits (D, C, B, A) le nombre de 1 est pair, sinon P vaut 0. 1. Etablir la table de vrit de cette fonction. On considrera que 0 fait partie des nombres dont la parit est paire. 2. Implanter cette fonction avec 3 ou exclusif et un inverseur. Exercice 2.4 Simplifier les fonctions suivantes en utilisant les tableaux de Karnaugh : Y1 = (A + B).A + A.B , Y2 = A. B + A. B + A.B , Y3 = A + B + A.B .

78

Exercice 2.5 Simplifier les fonctions suivantes en utilisant les tableaux de Karnaugh. Les implanter ensuite avec des portes NAND, puis des portes NOR. Y1 = A.B + A. C + B. C Y2 = A.B. C + A.B. C + A.B. C + A.B.C + A.B.C Y3 = A. B. C .D + A. B.C.D + A.B. C.D + A.B.C.D + A.B. C.D + A.B.C.D + A. B. C .D + A. B.C.D Y4 = B. C + A.D + A.B.D + A. B.C.D + A. B.C.D Y5 = (A + B + C ).(A + B + C).(A + B + C).(A + B + C ) Y6 = ( B + C).(A + C ).(A + C ) Y7 = (A + B).(A + B + C).(A + B + C).(A + B + C + D).(A + B + C + D)

Exercice 2.6 On souhaite faire la synthse dun dcodeur 3 vers 8 avec les sorties actives au niveau bas.

C B A Dcodeur 3 vers 8

Y0 Y1 Y2 Y3 Y4 Y5 Y6 Y7

1. Etablir la table de vrit du circuit. 2. Dterminer les fonctions de sortie Yi = f(C, B, A). 3. Donner une implantation avec des portes NAND. 4. Comment faut-il modifier le schma pour ajouter au montage une entre de validation V telle que le circuit fonctionne normalement quand V =1 et que toutes les sorties Yi = 1 quand V =0 ? Exercice 2.7 Donnez lquation logique S=f(A, B, C, D, E) du montage suivant :

79

0 1 1 0 A B 1 1 0 1 C D E

E0 Mux E1 4 vers 1 E2 E3 a1 a0

S1

E0 Mux E1 4 vers 1 E2 E3 a1 a0

S2

0 0

E0 a1 a0 Mux E1 4 vers 1 E2 E3

Exercice 2.8 Raliser un multiplexeur 32 vers 1 partir de 4 multiplexeurs 8 vers 1 et dun multiplexeur 4 vers 1. Exercice 2.9 Un appareil comporte trois cuves contenant de leau, du cassis et de la menthe. Trois boutons e, m, c commandant des lectrovannes E, M, C permettent dobtenir de leau pure, de la menthe leau ou du cassis leau. Une pice P doit tre introduite sauf pour leau pure qui est gratuite. Le dclenchement dun bouton quelconque e, m, c ou lintroduction de la pice dclenche une temporisation. Si celle-ci arrive son terme avant quun choix cohrent ait t fait, la pice ventuellement introduite est rendue (fonction P de restitution). La pice est galement rendue en cas de fausse manuvre. 1. Ecrire les quations logiques de commande des lectrovannes E, M, C et la fonction de retour de la pice P en fonction des variables e, m, c et p. On ne tiendra pas compte de la temporisation. 2. Simplifier les quations logiques laide des tableaux de Karnaugh. 3. Raliser la fonction laide dune PROM 32x8. 4. Raliser la fonction laide de portes NAND.

80

Exercice 2.10 Un systme reoit, cods en binaire naturel, des nombres compris entre 0 et 20 (inclus). Les digits dentre sont par poids dordre croissant A, B, C, D et E. Le systme dlivre trois informations S, T et U :

La sortie S vaut 1 lorsquun nombre divisible par trois se prsente lentre. La sortie T vaut 1 lorsquun nombre divisible par cinq se prsente lentre. La sortie U vaut 1 lorsquun nombre divisible par sept se prsente lentre.
1. Donner la table de vrit du systme. 2. Simplifier les quations logiques laide des tableaux de Karnaugh. 3. Raliser les fonctions T et U laide de portes NAND. 4. Raliser les fonctions S, T, U laide dune PROM 32x8. Exercice 2.11 On souhaite raliser un comparateur travaillant sur deux bits. Il possde deux entres sur deux bits appeles AB et CD et 4 sorties : AB = CD (EQ), AB CD (NE), AB < CD (LT) et AB > CD (GT). 1. Donner la table de vrit du circuit. 2. Simplifier les quations logiques laide des tableaux de Karnaugh. 3. Raliser la fonction laide de portes NAND. 4. Raliser la fonction laide dune PROM 32x8. Exercice 2.12 Soit un circuit NAND (caractristiques temporelles : tPLH = tPHL = 15 ns). Complter le chronogramme suivant.

81

E1 [V]

1,5 100 E2 [V] t [ns]

1,5 100 S [V] t [ns]

100

t [ns]

Exercice 2.13 Soit un circuit inverseur avec trigger de Schmitt SN74LS14. Ses tensions de seuil de basculement typiques positives et ngatives sont les suivantes : VT+ = 1,6 V, VT- = 0,8 V. 1. Dessiner sa fonction de transfert Vs = f(Ve). 2. Dfinir et donner la valeur de son hystrsis.

82

3 Reprsentation des nombres


3.1 Les codes

On regroupe souvent les bits par paquets afin de coder des nombres entiers, rels ou bien des caractres. Pour cela, un groupe de bits doit former un code. Il existe de trs nombreux codes et nous allons voir maintenant les principaux.

3.1.1 Entiers naturels


3.1.1.1 Base dun systme de numration

Une base est constitue par lensemble des chiffres (ou caractres) diffrents quutilise le systme de numration. Tout nombre peut se dcomposer en fonction des puissances entires, positives ou ngatives, de la base de numration. Il peut donc se mettre sous forme polynomiale. Prenons lexemple de la base 10. Dans la base dcimale, un chiffre peut prendre 10 valeurs de 0 9. Un nombre est un polynme en puissance de 10, 10n avec n positif, nul ou ngatif. Par exemple : base (93452)10

Chiffre de poids fort La forme polynomiale est :

Chiffre de poids faible

(93452)10 = 9.104 + 3.103 + 4.102 + 5.101 + 2.100 rang 4 3 2 1 0

Un autre exemple avec un nombre rel : (23,64)10 = 2.101 + 3.100 + 6.10-1 + 4.10-2 rang 1 0 -1 -2

Le rang du chiffre dun nombre reprsent dans une base est lexposant de la base associ ce chiffre, dans la reprsentation polynomiale considre.

83

Soit dune manire gnrale, une base b contenant b caractres ai tels que ai (0, 1, 2, , (b1)). La reprsentation polynomiale dun nombre entier N est :

N = ai .b i , n tant le rang du chiffre de poids fort.


i =0

Parmi toutes les bases possibles, 2 sont particulirement intressantes, les bases 2 et 16. La base 2 permet de traduire sous forme numrique ltat des variables boolennes (vrai = 1 / faux = 0 en logique positive). Les ai peuvent donc valoir (0, 1) et la reprsentation polynomiale est : (10110)2 = 1.24 + rang 4 0.23 + 3 1.22 + 2 1.21 + 1 0.20 0

Le bit le plus gauche est le bit de poids fort (MSB : Most Significant Bit), le bit le plus droite est le bit de poids faible (LSB : Least Significant Bit). Un chiffre en base 16 peut prendre 16 valeurs allant de 0 15. Il peut tre cod avec 4 bits. Comme les chiffres sarrtent 9 en dcimal, on utilise les lettres a, b, c, d ,e et f pour reprsenter les derniers tats.

dcimal binair hexadcimal e 0 0000 0 1 0001 1 2 0010 2 3 0011 3 4 0100 4 5 0101 5 6 0110 6 7 0111 7 8 1000 8 9 1001 9 10 1010 a 11 1011 b 12 1100 c 13 1101 d 14 1110 e 15 1111 f

84

La reprsentation polynomiale en base hexadcimale (base 16) est : (a0c25)16 = 10.164 + 0.163 + 12.162 + 2.161 + 5.160 rang 4 3 2 1 0

3.1.1.2 Changement de base

Une question importante est le passage dune base lautre : le changement de base. Soit (N)10, combien vaut (N)2 ou (N)16. La conversion vers la base 10 est la plus simple. Il suffit de calculer la valeur du polynme. En reprenant les exemples prcdents, il est vident que (au moins avec une calculatrice) : (10110)2 = 1.24 + 0.23 + 1.22 + 1.21 + 0.20 = (22)10 (a0c25)16 = 10.164 + 0.163 + 12.162 + 2.161 + 5.160 = (658469)10

Remarque : il existe en binaire un regroupement trs utile, loctet (ou byte) qui est un groupe de 8 bits. Par exemple loctet : (10000001)2 = 1*27 + 1*20 = (129)10

La valeur dun octet est comprise entre 0 et (255)10. Pour raccourcir lcriture, on utilise
souvent la notation hexadcimale (base 16) en regroupant les bits par paquets de 4. Par exemple loctet : (10000001)2 = (81)16

Le changement de base dcimal binaire est moins vident. Il faut diviser le nombre convertir par 2. On conserve le reste (qui vaut 0 ou 1) et on rpte la division sur le quotient,

85

jusqu ce que le quotient vaille 0. On crit alors tous les restes la suite, le premier reste obtenu tant le poids faible. Exemple :
47 1 2 23 1 2 11 1 2 5 1 2 2 0 2 1 1 On obtient : (47)10 = (101111)2 2 0

Le passage dhexadcimal vers binaire et de binaire vers hexadcimal est plus simple. Dans le premier cas, il suffit de remplacer chaque chiffre hexadcimal par le groupe de 4 bits correspondant (voir tableau de conversion). Exemple : (ab85)16 = (1010 1011 1000 0101)2 Dans le deuxime cas, il suffit de regrouper les bits par paquet de 4 en partant du poids faible. Il faudra ventuellement rajouter des bits 0 gauche pour terminer le groupe de 4 bits de poids fort. Exemple : (101001000010101111)2 = (0010 1001 0000 1010 1111)2 = (290af)16

Pour passer dhexadcimal en dcimal (et vice versa), vous pouvez passer par lintermdiaire du binaire ou faire le calcul directement par la mthode des divisions successives.

86

3.1.2 Entiers signs


La mthode naturelle pour coder un nombre avec signe est dutiliser la mthode traditionnelle de la base 10 : on indique le signe suivi de la valeur absolue du nombre. Ce type de code est connu sous le nom de signe-valeur absolue . En binaire, cela signifie que pour un nombre cod sur N bits, le bit de poids fort sert coder le signe (0 = +, 1 = -) et les N-1 bits restant codent la valeur absolue du nombre. Par exemple : (-16)10 = (1 10000)2 Dans un tel code, la plage des valeurs que lon peut coder (la dynamique) est : 2N-1-1 2 1 0 -0 -1 -2 -(2 1)
N-1

0 1111 0 0010 0 0001 0 0000

vous noterez quil y a deux valeurs 0

1 0000 1 0001 1 0010 1 1111

Cette mthode simple pour ltre humain est plutt complique utiliser dans un ordinateur (ou un circuit numrique) car pour additionner ou soustraire deux nombres, il faut commencer par dterminer quel sera le signe du rsultat ce qui oblige commencer tout calcul par une comparaison qui fait intervenir les signes et les valeurs absolues des deux nombres. Cest la raison pour laquelle on utilisera plutt le code complment 2. Le code complment 2 est le code utilis pour reprsenter les nombres entiers dans un ordinateur. Il nest pas trs parlant pour un tre humain, mais il prsente lintrt majeur de permettre une arithmtique simple (notamment, il ny a plus de soustraction). La construction du code sur n bits dcoule directement de la dfinition modulo 2n des nombres binaires. Etant donn un nombre A : 87

Si A 0, le code de A est lcriture en binaire naturel de A, ventuellement complt gauche par des 0. Par exemple, A = (23)10, cod sur 8 bits scrit : (00010111)ca2. Si A < 0, le code de A est lcriture en binaire naturel de 2n - |A| ou ce qui revient au mme 2n + A. Par exemple, A = (-23)10, cod sur 8 bits scrit : (11101001)ca2 qui est la reprsentation en binaire naturel de (256)10 - (23)10 = (233)10.

On remarquera que le bit de poids fort indique le signe (0 = +, 1 = -). Le calcul de loppos dun nombre cod sur n bits est toujours : -A = 2n - A modulo 2n. Par exemple -(-23) = 256 + 23 modulo 256 = 23. Il existe une astuce de calcul pour obtenir lexpression binaire de linverse dun nombre dont on connat le code :

On remarque que 2n - A = 2n - 1 - A + 1. On sait que 2n 1 est le nombre dont tous les chiffres valent 1. On en dduit que 2n - 1 A est le nombre que lon obtient en remplaant dans le code de A les 1 par des 0 et rciproquement. Ce nouveau nombre sappelle le complment 1 de A et se note Aca1 ou A . On en dduit finalement que : -A = Aca1 + 1

Par exemple : (23)10 = (00010111)2 = (11101000)ca1 -23 = (11101000)ca1 + 1 = (11101001)ca2 La lecture en dcimal dun nombre binaire cod en CA2 est simple si on garde en mmoire le poids de chaque rang (avec le rang de poid fort ngatif) : 1.-24 + 0.23 + 1.22 + 1.21 + 0.20 = (-10)10

(10110)CA2 =

Il faut absolument connaitre lavance le nombre de bits utiliss pour coder la valeur. Dans le cas prcdent, le nombre cod sur 5 bits est ngatif. Cod sur 8 bits (avec les trois 0 implicites gauche du nombre que lon ne place gnralement jamais en binaire naturel), il est positif. (00010110)CA2 = 0.27 + 0.26 + 0.25 + 1.24 + 0.23 + 1.22 + 1.21 + 0.20 = (22)10

88

Dans ce code, la dynamique est : 2N-1-1 2 1 0 -1 -2 -(2N-1) 0 1111 0 0010 0 0001 0 0000 1 1111 1 1110 1 0000

Un des avantages de ce code est que la soustraction nexiste plus. Au lieu de soustraire un nombre, il ny a qu additionner linverse de ce nombre. Par exemple, au lieu de calculer 50 23, on va pouvoir calculer 50 + (-23). Cela parat bte, mais cela limine la ncessit dutiliser un soustracteur binaire. On nutilise en conception logique que des additionneurs. Un autre avantage du code complment 2 est que si on effectue des additions successives, tant que le rsultat final est dans la dynamique autorise (pas de dbordement du rsultat final), on peut ignorer les dbordements ventuels des rsultats intermdiaires de calcul. Par exemple, on code avec 3 bits (dynamique de -4 +3) et on additionne 2 + 2 - 3 ce qui doit donner 1 en base 10. Lors du premier calcul, 2 + 2 = 4, il y a un dbordement mais le rsultat final est quand mme bon. En effet, (010)CA2 + (010)CA2 = (100)CA2 qui vaut -4 (donc dbordement) mais (100)CA2 + (101)CA2 = (001)CA2 ce qui donne bien 1. Cela parat magique, mais en fait, cest une consquence directe de larithmtique modulo 2n. Il y a malgr tout des inconvnients au code complment 2 en ce qui concerne les comparaisons, les multiplications et les divisions, mais ses avantages lemportent largement sur ses inconvnients.

3.1.3 Nombres rels


3.1.3.1 Virgule flottante

Les nombres flottants (floating point numbers) permettent de reprsenter, de manire approche, une partie des nombres rels. La valeur dun rel ne peut tre ni trop grande, ni trop prcise. Cela dpend du nombre de bits utiliss (en gnral 32 ou 64 bits). Cest un

89

domaine trs complexe et il existe une norme, IEEE-754, pour que tout le monde obtienne les mmes rsultats (faux bien sur). Le codage en binaire est de la forme :

s : signe

e : exposant (sign)

zzzz : partie fractionnaire de la mantisse (non sign)

Cest--dire que si X est un nombre flottant : X = (-1)s x 2e x 1.zzzz o s est le signe de X, e est lexposant sign et zzzz est la partie fractionnaire de la mantisse. Cest, en binaire, la notation scientifique traditionnelle. Voici quelques exemples de formats usuels : nombre de bits format binaire (s + e + zzzz) 32 64 80 1 + 8 + 23 1 + 11 + 52 1 + 15 + 64 valeur max 2128 10+38 21024 10+308 216384 10+4932 prcision max 2-23 10-7 2-52 10-15 2-64 10-19

Le calcul en virgule flottante est trs coteux en termes de portes et de consommation (mais pas en frquence de fonctionnement). Il est donc rarement utilis en lectronique numrique (comme en DSP dailleurs). On utilise plutt le calcul en virgule fixe.
3.1.3.2 virgule fixe

Le calcul avec des nombres en virgule fixe (fixed point numbers) revient faire tous les calculs avec des entiers en recadrant les rsultats laide dune virgule fictive. Transposer un algorithme utilisant des flottants et le passer en virgule fixe est une tche longue et dlicate dans le cas gnral.

3.1.4 Des codes particuliers


3.1.4.1 Le code BCD

Le code BCD (Binary Coded Decimal) permet de coder un nombre dcimal en binaire. A chaque chiffre dcimal, on fait correspondre un groupe de 4 bits comme pour la base hexadcimale. Mais ici, il ny a pas de valeur suprieure 9. Le code est le suivant :

90

dcimal 0 1 2 3 4 5 6 7 8 9

BCD 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001

On voit que cest un code incomplet car il nutilise que 10 combinaisons sur les 16 possibles. Ce code est utile quand on veut traiter des nombres dcimaux en lectronique numrique (par exemple pour dialoguer avec un tre humain ou pour compter directement en dcimal).
3.1.4.2 Le code Gray

Le code Gray est un code adjacent (o un seul bit change quand on passe dune valeur la valeur suivante). On lappelle aussi le code binaire rflchi. On lutilise dans les tableaux de Karnaugh mais aussi en conception numrique. Voici un exemple de code Gray sur 3 bits :

g2 0 0 0 0 1 1 1 1

gray g1 0 0 1 1 1 1 0 0

g0 0 1 1 0 0 1 1 0

La construction peut se faire graphiquement par itration ou bien partir du code en binaire naturel. Graphiquement : on part de 0 1 puis on cre un axe de symtrie 0 1 1 0

91

On ajoute le bit de poids fort en binaire naturel. 0 0 1 1 0 1 1 0

Pour prolonger le code (passer sur 3 bits), on rcre un nouvel axe de symtrie sur les deux bits faibles, puis on ajoute un bit supplmentaire en binaire naturel : 0 0 0 0 1 1 1 1 0 0 1 1 1 1 0 0 0 1 1 0 0 1 1 0

Et on recommence si on veut ajouter un bit supplmentaire. En comparant le code binaire naturel et le code Gray sur 3 bits : binaire b2 b1 b0 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 Gray g2 g1 g0 0 0 0 0 0 1 0 1 1 0 1 0 1 1 0 1 1 1 1 0 1 1 0 0

On en dduit les quations et les schmas suivants : De binaire naturel vers code Gray g0 = b0b1 g1 = b1b2 g2 = b2 92 De code Gray vers binaire naturel b0 = g0b1 b1 = g1b2 b2 = g2

b0 g0

g0 b0

b1 g1

g1 b1

b2

g2

g2

b2

Sur un nombre quelconque de bits, on obtient les quations : De binaire naturel vers code Gray gi = bi XOR bi+1 pour 0 < i < N-2 gN-1 = bN-1 De code Gray vers binaire naturel bi = gi XOR bi+1 pour 0 < i < N-2 gN-1 = bN-1

Le transcodage binaire-Gray est utilis par exemple pour raliser un compteur. On compte en binaire, puis on transcode en Gray. Le transcodage Gray-binaire est rarement utilis cause du cumul des temps de propagation dans le montage qui le rend beaucoup plus lent que le transcodage binaireGray.
3.1.4.3 Le code Johnson

Le code Johnson est un autre exemple de code adjacent que lon peut utiliser la place du code Gray. En voici un exemple sur 3 bits :

Johnson b2 b1 b0 0 0 0 1 1 1 0 0 1 1 1 0 0 1 1 1 0 0

On voit que cest un code incomplet car il nutilise que 6 combinaisons sur les 8 possibles.

93

3.1.4.4 Le code 1 parmi N

Le code 1 parmi N est trs utilis en conception numrique, notamment pour encoder les machines tats finis. Les Amricains lappellent le codage one hot . En voici un exemple sur 3 bits : 1 parmi 3 b2 b1 b0 0 0 1 0 1 0 1 0 0

On voit que cest un code incomplet car il nutilise que 3 combinaisons sur les 8 possibles.
3.1.4.5 Le code ASCII

Il ny a pas que les nombres qui doivent tre cod en binaire, mais aussi les caractres comme les lettres de lalphabet, les signes de ponctuation, Le code le plus connu et le plus utilis est le code ASCII (American Standard Code for Information Interchange). Le code ASCII est un jeu normalis de 128 caractres cods sur 7 bits, devenu un standard quasi universel. Il comporte tous les caractres alphanumriques non accentus et est lisible par pratiquement n'importe quelle machine. Ce sont les 8 premires lignes du tableau suivant.

Les 32 premiers codes sont utiliss comme caractres de contrle pour reprsenter, par exemple, une fin de ligne ou une tabulation. Le code ASCII ne contient pas de caractres 94

accentus et il a t complt par le code ISO-8859-1 (ou Latin 1). Les 128 premiers caractres correspondent au code ASCII, les 128 suivants aux caractres accentus et caractres spciaux (voir les 8 dernires lignes du tableau). Unicode est un jeu de caractres cod sur 16 bits (contre 7 ou 8 bits pour les standards actuels) qui permet le codage des caractres utiliss par toutes les langues du monde au sein d'une table unique. 16 bits permettent de coder 65 536 (216) caractres diffrents ce qui couvre largement les besoins en la matire. Les 256 premiers caractres d'Unicode correspondent au jeu ISO Latin 1.
3.1.4.6 Les codes dtecteurs et/ou correcteurs derreurs

Si on craint que des erreurs se produisent dans un mot binaire (au cours dune transmission par exemple), on rajoute au code des bits supplmentaires pour que le rcepteur puisse dtecter les erreurs et ventuellement les corriger. Par exemple, il y a un code dtecteur et correcteur derreurs dans le train binaire enregistr sur un compact disque audio (code ReedSolomon). Ces codes redondants sont un domaine dtude complet de la thorie de linformation.
3.2 Les circuits arithmtiques

Les circuits arithmtiques effectuent des oprations binaires (signes ou non signes) telles que laddition, la multiplication, la comparaison ou combinent ces oprateurs de base au sein dune UAL (Unit Arithmtique et Logique).

3.2.1 Ladditionneur/soustracteur
Prenons lexemple dune addition en binaire naturel sur 4 bits : A B S (5)10 (3)10 (8)10 (0101)2 (0011)2 (1000)2

1re colonne : 1 + 1 = 0 avec une retenue sortante 1 ((2)10 = (10)2). 2me colonne : la retenue rentrante vaut 1. 1 + 0 + 1 = 0 avec une retenue sortante 1. 3me colonne : la retenue rentrante vaut 1. 1 + 1 + 0 = 0 avec une retenue sortante 1. 4me colonne : la retenue rentrante vaut 1. 1 + 0 + 0 = 1.

95

Sur les deux colonnes du milieu, il y a une retenue entrante et une retenue sortante. On peut donc dfinir les entres-sorties dun additionneur traitant le ime bit du calcul :
Ai Bi

Ci

Additionneur 1 bit

Ci-1

Si

Lentre Ci-1 est la retenue entrante (Carry en anglais) et la sortie Ci est la retenue sortante. Vous pouvez voir le schma interne de cet additionneur dans le corrig de lexercie 3.5 (8.2). Ladditionneur complet est construit de la manire suivante :

A3

B3

A2

B2

A1

B1

A0

B0

C3 Additionneur C2 Additionneur C1 Additionneur C0 Additionneur 1 bit 1 bit 1 bit 1 bit Rang 3 Rang 2 Rang 1 Rang 0

C-1 = 0

S3

S2

S1

S0

Vu de lextrieur, un additionneur (ou un soustracteur, en CA2 cest la mme chose) se prsente donc sous la forme suivante.

A1 A2 A3 A3 B1 B2 B3 B4 Cin 96

1 2 3 4

Cout

Ils effectuent laddition (ou la soustraction) de deux nombres cods sur N bits. Le rsultat est cod sur N bits avec une sortie supplmentaire pour la retenue. Il y a aussi une entre de retenue pour pouvoir mettre en cascade les circuits. Sur 4 bits, Lopration ralise sous forme dcimale est (le + est une addition, le . est une multiplication) : Cin + (A1+B1)+2.(A2+B2)+ 4.(A3+B3)+8.(A4+B4) = 1+2.2+4.3+8.4+16.Cout

3.2.2 Dbordement de calcul


Le rsultat dune addition ou dune soustraction est suppos tenir dans la plage de la dynamique choisie pour reprsenter les nombres. Si N bits ont t choisis en CA2, alors le rsultat doit tenir dans la plage -2N-1 : 2N-1-1. Si le rsultat de lopration ne tient pas dans cette plage, alors on dit quil y a dbordement de calcul ( arithmetic overflow ). Pour sassurer du bon fonctionnement dun circuit arithmtique, il faut tre capable de dtecter ce dbordement. Prenons lexemple des 4 oprations possibles avec les valeurs 7 et 2 en CA2 cod sur 4 bits. Les retenues C2 et C3 sont celles qui ont t dfinies au paragraphe prcdent.

(+7) + (+2) +9

0111 + 0010 1001 C2=1, C3=0 0111 + 1110 10101 C2=1, C3=1

(-7) + (+2) -5

1001 + 0010 1011 C2=0, C3=0 1001 + 1110 10011 C2=0, C3=1

(+7) + (-2) +5

(-7) + (-2) -9

La plage utilisable en CA2 4 bits est comprise entre -8 et +7. Les rsultats +9 et -9 dbordent donc (les deux oprandes ont mme signe), mais pas les rsultats +5 et -5 (les deux oprandes ont des signes contraires). On voit que le rsultat est correct quand les deux retenues C2 et C3 sont identiques et quil y a dbordement quand elles sont diffrentes. Dans notre exemple, la dtection du dbordement est donc : overflow = C2 C3 et dune manire gnrale sur N bits :
overflow = CN-2 CN-1

97

Il est donc facile de rajouter ce ou exclusif sur un additionneur pour vrifier les dbordements. Pour sassurer de labsence de dbordement, on peut aussi remarquer que laddition ou la soustraction de deux nombres cods sur N bits donne un rsultat cod sur N+1 bits. Si on prvoit au dpart le nombre de bits ncessaire pour contenir le rsultat, le dbordement est impossible. Retenez-donc que : N bits N bits = N+1 bits

3.2.3 Le comparateur
Les comparateurs sont une autre grande famille de circuit arithmtique. Ils effectuent sur N bits, les oprations dgalit, de supriorit ou dinfriorit. Le circuit suivant est un comparateur sur 4 bits :
A0 A1 A2 A3 B0 B1 B2 B3

OA>B OA<B OA=B

La table de vrit dun comparateur non sign sur 2 bits est la suivante :

A1 A0 B1 B0 A=B A>B A<B 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0 1 1 0 0 1 0 1 0 1 0 1 0 1 0 1 0 98 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 0

1 1 1 1 1

0 1 1 1 1

1 0 0 1 1

1 0 1 0 1

0 0 0 0 1

0 1 1 1 0

1 0 0 0 0

3.2.4 Le multiplieur
La multiplication est une opration complique raliser et consommatrice de ressources en portes logiques. Avant toute tude, il faut sassurer que cette opration est indispensable dans le design. Il faut remarquer tout dabord quun dcalage gauche dun mot binaire correspond une multiplication par 2 et quun dcalage droite correspond une division par 2. Cela implique que :

Dcalage de k bits gauche (<< k) = Multiplication par 2k Dcalage de k bits droite (>> k) = Division par 2k Ceci est parfaitement exact pour un nombre non sign, mais demande tre regard de plus prs pour un nombre en CA2. Prenons un exemple de nombre positif (31) cod en CA2 8 bits et dcalons-le de 3 rangs vers la gauche.

00011111 << 3 = 11111000 = -8

31x8 nest pas gal -8, mais le bon rsultat (248) ne tient pas sur 8 bits. En ralisant le dcalage, on a dbord par valeur positive et le rsultat est devenu ngatif. Pour raliser lopration, il faut vrifier au pralable quil y a suffisamment de bits disponibles. Prenons un autre exemple avec cette fois un nombre ngatif (-8), et dcalons-le de 1 rang vers la droite.

11111000 >> 1 = 01111100 = 124

-8/2 nest pas gal 124. Le problme ici vient du fait que lon a insr un 0 gauche du nombre. Or en CA2, il faut effectuer dans ce cas ce que lon appelle lextension de signe. En cas de dcalage droite, si le bit de poids fort (MSB) est gal 0 (nombre positif), alors on

99

insre un 0 gauche et si le MSB est gal 1 (nombre ngatif) alors on insre un 1 gauche. Les rsultats sont alors corrects (en prenant la partie entire du rsultat bien sur) :

31/8 = 00011111 >> 3 = 00000011 = 3 -8/4 = 11111000 >> 2 = 11111110 = -2

Est-il possible de faire mieux avec un simple dcalage et une addition ? Supposons que lon souhaite effectuer lopration : S = A x 9. On remarque que A x 9 = A x 8 + A. Donc, on peut raliser le montage suivant :
A

<< 3 + S = 9.A

Cette mthode permet de raliser un grand nombre de multiplication avec un cot assez faible. En effet, un dcalage constant de N bits gauche ne consomme en gnral aucune porte logique. Voyez sur lexemple suivant une multiplication par 20 avec des nombres CA2 cods sur 16 bits :

A (en CA2 16 bits)

0000

00

+ S = 20.A

Le dcalage constant gauche consiste simplement insrer k bits 0 droite de A et ignorer les k bits gauche de A. 100

La vraie multiplication (quelconque et non constante) est une opration beaucoup plus complique. Prenons un exemple non sign sur 4 bits (11x14 = 154) et effectuons le calcul la main :
(14) multiplicande x (11) multiplieur

(154) produit

1110 x 1011 1110 1110 0000 1110 10011010

Il faut tout de suite remarquer que dans notre exemple, 4 bits x 4 bits = 8 bits. Dune manire gnrale :

N1 bits x N2 bits = N1+ N2 bits La multiplication non signe consiste en une srie daddition de la version dcale du multiplicande l o le bit correspondant du multiplieur vaut 1 (algorithme Shift and Add ). Cette mthode ne marche absolument pas en CA2. Il suffit pour sen persuader de regarder lexemple suivant :
(-1) multiplicande x ( 1) multiplieur

(15) produit

1111 x 0001 1111 0000 0000 0000 0001111

Pour que cet algorithme marche en CA2, il faut convertir les deux oprandes en valeurs positives et faire la multiplication en non sign ce qui donne un rsultat sur 6 bits. Puis on regarde les signes du multiplieur et du multiplicande. Sils sont identiques, le rsultat est positif et il faut ajouter 00 gauche du produit. Sils sont diffrents, le rsultat est ngatif et il faut convertir le produit en CA2 puis rajouter 11 sur sa gauche. Vous noterez que le rsultat comporte deux bits de signe identiques. Cet algorithme est beaucoup trop lourd pour quon lutilise rellement. De nombreuses tudes ont eu lieu pour dterminer des algorithmes plus efficaces tels que lalgorithme de Booth. Leur tude sort du cadre de ce cours. Il existe 101

aujourdhui dans les FPGA des multiplieurs cbls prt lemploi (par exemple : multiplieur sign CA2 18 bits x 18 bits = 36 bits).

3.2.5 Le diviseur
Plus encore que la multiplication, la division est le pire ennemi du designer. Elle est toujours plus lente quune multiplication (dans un microprocesseur style PowerPC, la multiplication se calcule en une priode dhorloge alors que la division se calcule en 4 priodes dhorloge). Dans la mesure du possible, on vite toujours dutiliser cette opration en conception de circuit intgr (ainsi dailleurs quen dveloppement logiciel). Si on ne peut pas lviter, la mthode des dcalages peut toujours tre utile pour une division par une puissance de 2. Dans le cas gnral, on pose Numrateur = Dnominateur x Quotient + Reste, ce qui donne :

N = Q, D

R < D , par exemple :

10 = 3, 3

R =1

Le problme du nombre de bits pour le codage na rien de simple. Supposons que N et D soient des entiers cods sur 16 bits, alors Q a de bonnes chances de rester 0 la plupart du temps, en tout cas ds que D sera plus grand que N ( 99 = 0 avec des entiers). Si N nest pas 100

beaucoup plus grand que D, le rsultat de la division risque dtre trs peu prcis. Si D = 0, la division est impossible. Pour sen sortir, il faut raisonner en virgule fixe. Un Q15/16 est un nombre cod sur 16 bits dont 15 droite de la virgule : -,---------------. Sa dynamique va de -1 +(1 - 2-15). Le bit gauche de la virgule est le bit de signe. Pour que la division ait une dynamique maximale en sortie, il faut effectuer 216. N = Q . Dun point de vue du codage, 216 x Q15/16 = Q31/32. On D

dcale la virgule de 16 rangs vers la gauche en multipliant par 216, ce qui donne -,--------------0000000000000000, donc un Q31/32 (dynamique : -1 +(1 - 2-15)). Regardons maintenant le codage en virgule fixe du rsultat de la division : Q 31 / 32 = Q16 / 32 Q15 / 16

102

Comment obtient-on Q16/32 en sortie ? Il faut raisonner en termes de dynamique. Prenons des valeurs positives : N max D min en entier : sur 16 bits : Nmax = 2 1 et Dmin = 1 Q = 216.( 215 1)/1 = 231-216 Q = 01111111111111110000000000000000 en virgule fixe : Nmax (en Q31/32) = (1 - 2-15) Dmin (en Q15/16) = 2-15 Q = (1 - 2-15)/ 2-15 = 215 1 Q = 0111111111111111,0000000000000000 la virgule est au milieu du mot, cest bien un Q16/32
15

N min D max en entier : sur 16 bits : Nmin = 1 et Dmax = 215 1 Q = 216.1/ (215 1) = 2,00006= 2 Q = 00000000000000000000000000000010 en virgule fixe : Nmin (en Q31/32) = 2-15 Dmax (en Q15/16) = 1 - 2-15 Q = 2-15 / (1 - 2-15) = 2-15 Q = 0000000000000000,0000000000000010 la virgule est au milieu du mot, cest bien un Q16/32

Facile non ? Vous noterez quil faut rester sur 32 bits pour conserver la dynamique complte de la division. Si vous dsirez revenir sur 16 bits, ce qui est en gnral le cas, il va falloir choisir les 16 bits extraire en fonction de la dynamique souhaite. La division ne marchera donc pas dans tous les cas. Il existe des algorithmes de calcul, qui consomment dans notre exemple entre 20 et 40 cycles dhorloge suivant le contenu de N et D. Le mme problme existe aussi avec un DSP. Ltude des algorithmes de division sort du cadre de ce cours. Il faut noter quil existe une mthode efficace quoique par forcment prcise qui consiste transformer la division en multiplication par linverse du dnominateur.
N 1 = N. D D

Q=

Il suffit maintenant de coder la valeur de 1/D dans une mmoire, de mettre D sur les adresses puis de lire 1/D sur les donnes :

103

M bits dadresses D

Mmoire 2M x O contient les valeurs de 1/D

O bits de donnes 1/D

Le choix de M et de O dpend des ressources disponibles, de la prcision dsire sur la valeur de 1/D et de lcart entre 2 valeurs de 1/D adjacentes. Avec cette mthode, la division N/D prend en gnral 2 priodes dhorloges, une pour laccs mmoire (qui est gnralement synchrone) et une pour la multiplication.
N 1 1 K = N. mais en posant n . D 2 D D

Une autre astuce est aussi possible avec la formule Q = Cela conduit au montage suivant :
K

>>n

Prenons lexemple dune division par 7 : K = 73, n = 9 do

1 73 = ce qui donne : D 512

Q = N.

73 N = 512 7.013

En jouant sur le nombre de bits de codage de K et n, on peut amliorer la prcision du calcul. Cette mthode est efficace (un cycle dhorloge) pour une division par une constante, mais la gestion de la prcision nest pas vidente si D a une dynamique trs leve. 104

3.3

Description en VHDL

3.3.1 Reprsentation des nombres en VHDL

Il existe deux types de donnes scalaires permettant de reprsenter des nombres en VHDL :
Les entiers (qui sont synthtisables) avec par exemple :
signal I : integer range -128 to 127; I sera cod sur 8 bits en CA2 signal J : integer range 0 to 15; J sera cod sur 4 bits non signs signal K : integer range -32768 to 32767; K sera cod sur 16 bits en CA2 signal L : integer; L sera cod sur 32 bits en CA2 (par dfaut)

Les rels (qui ne sont pas synthtisables mais que lon peut utiliser dans un testbench) avec

par exemple :
signal X : real; X peut tre compris entre -1038 et 1038 (float 32 bits par dfaut)

On peut aussi utiliser des tableaux de variables de type bit comme bit_vector ou de type std_logic comme std_logic_vector, ce dernier tant le plus utilis. Par dfaut, ils sont non typs et ne permettent donc pas les oprations arithmtiques telles que laddition ou la multiplication. Pour pouvoir faire de larithmtique notamment avec le type
std_logic_vector, on peut utiliser deux familles de packages quivalentes mais non

identiques : les packages propritaires synopsys (std_logic_arith, std_logic_unsigned et std_logic_signed abusivement placs dans la librairie IEEE) et les packages normaliss IEEE 1076.3 (numeric_bit et numeric_std). Les packages IEEE 1076.3 sont hlas arrivs trop tardivement (en 1997) alors que la premire version du langage VHDL (IEEE 1076) date de 1987 et que la socit Synopsys a dvelopp le premier synthtiseur en 1990. Comme il ny avait alors aucun package permettant linterprtation binaire pour larithmtique, Synopsys a dvelopp les siens et ils ont t repris par tous les autres fabricants de synthtiseurs. Les packages Synopsys sont devenus la norme de fait. Le temps que les packages IEEE soient dvelopps puis reconnus par les vendeurs doutils de synthse, tous les concepteurs avaient pris lhabitude dutiliser ceux de Synopsys dautant que les deux familles de packages offrent les mmes fonctionnalits. Aujourdhui, les packages Synopsys et IEEE sont reconnus par tous les synthtiseurs mais les packages Synopsys restent les plus utiliss. Voyons maintenant le contenu de ces derniers. 105

3.3.2 Le package std_logic_arith


3.3.2.1 Les types signed et unsigned

Les types signed et unsigned ont la mme dfinition que le type std_logic_vector (type std_logic_vector is array (NATURAL range <>) of std_logic;). Ce sont des types proches (closely related). Les oprateurs arithmtiques, de comparaisons et les fonctions de conversion dfinis dans std_logic_arith traiteront de la mme manire les types signed et
unsigned sauf que signed sera interprt comme un nombre binaire sign cod en CA2 et unsigned sera interprt comme un nombre binaire non sign. 3.3.2.2 Les fonctions de conversion
3.3.2.2.1 conv_integer

Cette fonction convertit un argument (arg) de type signed ou unsigned (mais pas un
std_logic_vector, voir 3.3.3) en integer :
function conv_integer(arg: unsigned) return integer; function conv_integer(arg: signed) return integer;

Exemples dutilisation :
signal signal signal signal b : std_logic_vector(3 downto 0); u1 : unsigned(3 downto 0); s1 : signed(3 downto 0); i1, i2, i3 : integer;

u1 <= "1001"; s1 <= "1001"; b <= "0001"; i1 <= conv_integer(u1); i2 <= conv_integer(s1); i3 <= conv_integer(b);

-- 9 -- -7 -- erreur en simulation et synthse

3.3.2.2.2 conv_unsigned

Cette fonction convertit un argument de type signed ou integer (mais pas un


std_logic_vector, voir 3.3.3) en unsigned sur size bits.
function conv_unsigned(arg: integer, size: integer) return unsigned; function conv_unsigned(arg: signed, size: integer) return unsigned;

Exemples dutilisation :
signal u1, u2 : unsigned(3 downto 0); signal s1 : signed(3 downto 0); signal i1, i2 : integer; s1 <= "0101"; i1 <= 13;

106

u1 <= conv_unsigned(s1, 4); u2 <= conv_unsigned(i1, 4);

-- = "0101" = 5 -- = "1101" = 13

3.3.2.2.3 conv_signed

Cette fonction convertit un argument de type unsigned ou integer (mais pas un


std_logic_vector, voir 3.3.3) en signed sur size bits.
function conv_signed(arg: integer, size: integer) return signed; function conv_signed(arg: unsigned, size: integer) return signed;

Exemples dutilisation :
signal u1 : unsigned(3 downto 0); signal s1, s2, s3 : signed(3 downto 0); signal i1, i2 : integer; u1 <= "0101"; i1 <= 6; i2 <= -2; s1 <= conv_signed(u1, 4); s2 <= conv_signed(i1, 4); s3 <= conv_signed(i2, 4); -- = "0101" = +5 -- = "0110" = +6 -- = "1110" = -2

3.3.2.2.4 conv_std_logic_vector

Cette fonction convertit un argument de type signed, unsigned ou integer en std_logic_vector sur size bits.
function conv_std_logic_vector(arg: integer, size: integer) return std_logic_vector; function conv_std_logic_vector(arg: unsigned, size: integer) return std_logic_vector; function conv_std_logic_vector(arg: signed, size: integer) return std_logic_vector;

Exemples dutilisation :
signal signal signal signal u1 s1 i1 i2 v1 v2 v3 v4 <= <= <= <= <= <= <= <= u1 : unsigned(3 downto 0); s1 : signed(3 downto 0); v1, v2, v3, v4 : std_logic_vector(3 downto 0); i1, i2 : integer;

"1101"; "1101"; 13; -2; conv_std_logic_vector(u1, conv_std_logic_vector(s1, conv_std_logic_vector(i1, conv_std_logic_vector(i2, 4); 4); 4); 4); ----= = = = "1101" "1101" "1101" "1110"

3.3.2.2.5 Conversion de types proches (closely related)

Si les types convertir sont suffisamment proches, le type lui-mme peut servir de fonction de conversion. Par exemple on peut crire signed(i) ou unsigned(j) ou encore
std_logic_vector(k). Le mlange des types tant interdit en VHDL (le langage est

107

fortement typ), il faut faire la conversion mme si les types ont la mme dfinition. Bien sur, les valeurs ne changent pas. Voici des exemples dutilisation :
signal signal signal signal u1, s1, v1, i1, u2, u3 : unsigned(3 downto 0); s2, s3 : signed(3 downto 0); v2, v3 : std_logic_vector(3 downto 0); i2 : integer;

u3 <= "1101"; s3 <= "0001"; v3 <= "1001"; v1 v2 s1 s2 u1 u2 i1 <= <= <= <= <= <= <= std_logic_vector(u3); -- = "1101" std_logic_vector(s3); -- = "0001" signed(u3); -- = "1101" signed(v3); -- = "1001" unsigned (v3); -- = "1001" unsigned (s3); -- = "0001" conv_integer(unsigned(v3)); -- conv_integer naccepte pas les std_logic_vector

3.3.2.3 Oprateur arithmtiques : +, -, *

Chaque oprateur peut porter sur un type signed, unsigned ou integer mais en aucun cas sur un std_logic_vector (voir 3.3.3). Voici des exemples dutilisation :
signal signal signal signal signal signal u1, u2 : unsigned (3 downto 0); s1, s3 : signed (3 downto 0); s2 : signed (4 downto 0); v1 : std_logic_vector (3 downto 0); v2 : std_logic_vector (4 downto 0); i1, i2 : integer; -- = 9 -- = -7 ----= = = = 2 "00010" 7 : erreur la synthse car i1=32 bits et u1=4 bits 7

u1 <= "1001"; s1 <= "1001"; i1 <= 16; s2 v2 u2 s3 <= <= <= <= u1 + s1; u1 + s1; i1 - u1; -s1;

3.3.2.4 Oprateurs de comparaison : <, <=, >, >=, =, /=

Chaque oprateur peut porter sur un type signed, unsigned ou integer mais en aucun cas sur un std_logic_vector (voir 3.3.3). Il retourne un boolen (vrai/faux). On reconnait les comparaisons suivantes : < <= infrieur infrieur ou gal > >= suprieur suprieur ou gal = Egal

/= Diffrent de

Exemples dutilisation :
signal u1, u2 : unsigned (3 downto 0); signal s1 : signed (3 downto 0); signal o1,o2 : std_logic;

108

u1 <= "1001"; u2 <= "0111"; s1 <= "1001"; if u1 > u2 then o1 <= '1'; else o1 <= '0'; end if; if s1 > u2 then o2 <= '1'; else o2 <= '0'; end if;

-- = 9 -- = 7 -- = -7 -- o1 set to '1'

-- o2 set to '0'

3.3.2.5 Fonctions de dcalage : SHL, SHR

La fonction de dcalage gauche SHL (SHift Left) et droite SHR (SHift Right) portent sur un type signed ou unsigned. Lorsque SHR porte sur un type signed, il ralise lextension de signe.
function shl(arg: unsigned; count: unsigned) return unsigned; function shl(arg: signed; count: unsigned) return signed; function shr(arg: unsigned; count: unsigned) return unsigned; function shr(arg: signed; count: unsigned) return signed;

Il faut indiquer la fonction le nombre de dcalage prendre en compte avec une variable de type unsigned. Voici des exemples dutilisation :
architecture comporte of dec is signal u1, u2, u3 : unsigned(3 downto 0); signal s1, s2, s3 : signed(3 downto 0); begin u1 <= "0010"; u2 <= shl(u1, "10"); -- "1000" u3 <= shr(u2, "10"); -- "0010" : u2 non sign, pas dextension de signe s1 <= "0010"; s2 <= shl(s1, "10"); s3 <= shr(s2, "10"); end comporte ; -- "1000" -- "1110" : u2 sign, extension de signe

3.3.3 Les packages std_logic_unsigned et std_logic_signed

La fonction de conversion conv_integer() vue dans la std_logic_arith ne peut pas convertir un std_logic_vector en integer car elle ne peut pas dterminer sil sagit dune valeur signe ou non signe. Les packages std_logic_unsigned et std_logic_signed permettent de rsoudre ce problme. Ils contiennent les mmes oprateurs arithmtiques (+, -, *), de comparaisons (<, <=, >, >=, =, /=) et fonctions de dcalage (SHR, SHL) que la std_logic_arith plus la fonction conv_integer() qui accepte un std_logic vector et qui retourne un integer. 109

Si vous utilisez le package std_logic_unsigned avant la dclaration de lentit en VHDL, tous les std_logic_vector seront traits comme des entiers non signs (en fait, comme un type unsigned) y compris avec la fonction conv_integer(). Si vous utilisez le package std_logic_signed avant la dclaration de lentit en VHDL, tous les std_logic_vector seront traits comme des entiers signs (en fait, comme un type
signed) y compris avec la fonction conv_integer().

Attention, tous les std_logic_vector de lentit et de larchitecture seront soit signs, soit non signs. Le mlange des deux est impossible.

3.3.4 Exemples
3.3.4.1 Additionneur simple non sign ou sign

La ralisation dun additionneur 4 bits non sign est assez intuitive comme le montre lexemple suivant :
library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; entity add port(A : B : S : end add; is in std_logic_vector(3 downto 0); in std_logic_vector(3 downto 0); out std_logic_vector(3 downto 0));

architecture comporte of add is begin S <= A + B; end comporte ;

Il faut juste savoir que loprateur daddition + ne gre pas les retenues entrantes et sortantes. En clair, les deux entres et la sortie doivent tre de mme taille : N bits + N bits = N bits Dans cet exemple, lutilisation du package std_logic_unsigned implique que tous les
std_logic_vector sont considrs comme des unsigned. Le rsultat de la simulation

est le suivant : 110

1+4 = 5

15+1 = 16

7+8 = 15

Pour raliser un additionneur sign, il suffit de remplacer la ligne :


use IEEE.std_logic_unsigned.all;

par la ligne :
use IEEE.std_logic_signed.all;

Le rsultat de la simulation est alors :

1+4 = 5

-1+1 = 0

7-8 = -1

En interprtant les signaux A, B et S comme des nombres signs, on obtient bien les rsultats attendus. Mais en binaire, les rsultats sont strictement identiques lexemple non sign. Ceci est parfaitement normal puisque loprateur daddition agit de la mme manire sur les nombres signs et non signs.

Dans le cas dune addition, travailler en sign ou en non sign est une vue de lesprit. En binaire, les rsultats sont identiques dans les deux cas. Mais ce nest pas vrai pour les calculs de dbordement (overflow).
3.3.4.2 Additionneur avec retenue entrante et sortante

Pour pouvoir grer les retenues entrantes et sortantes sans trop de difficult, il suffit de raliser laddition avec 1 bit supplmentaire sur le poids fort. Dans lexemple suivant, on ralise une addition signe sur 4 bits en utilisant le package std_logic_arith (pour varier un peu car on aurait parfaitement pu utiliser la std_logic_signed, les deux solutions tant quivalentes).
library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_arith.all;

111

entity add port(Cin A B S Cout end add;

is : in std_logic; : in signed(3 downto 0); : in signed(3 downto 0); : out signed(3 downto 0); : out std_logic);

architecture comporte of add is signal Somme : signed(4 downto 0); begin Somme <= (A(3)&A) + (B(3)&B) + Cin; S <= Somme(3 downto 0); Cout <= Somme(4); end comporte ;

A la ligne :

Somme <= (A(3)&A) + (B(3)&B) + Cin;

A et B sont tendus sur 5 bits par concatnation (avec extension de signe car nous sommes en sign) puis additionns avec la retenue entrante Cin. Les parenthses sont obligatoires autour de la concatnation car laddition + est plus prioritaire que la concatnation &. Somme est sur 5 bits. La sortie S correspond aux 4 bits de poids faible de Somme et la retenue Cout correspond son bit de poids fort. On peut constater sur la simulation suivante que la gestion des retenues est correcte.

3.3.4.3 Additions multiples sans gestion de retenue

Quand on veut additionner plusieurs valeurs, la gestion des retenues peut devenir assez rapidement pnible. Il existe une mthode simple pour sen passer : il suffit de prvoir la taille du rsultat, de convertir les entres cette taille puis dadditionner sans soccuper des retenues. Dans lexemple suivant, on additionne 4 variables 4 bits A, B, C et D ce qui doit donner un rsultat sur 6 bits. On va convertir les entres sur 6 bits en concatnant 2 bits gauche de chaque variable (00 dans cet exemple puisque nous travaillons en non sign, avec extension de signe pour un exemple sign), puis effectuer laddition : 112

library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; entity add port(A : B : C : D : S : end add; is in std_logic_vector(3 downto 0); in std_logic_vector(3 downto 0); in std_logic_vector(3 downto 0); in std_logic_vector(3 downto 0); out std_logic_vector(5 downto 0));

architecture comporte of add is signal S1 : std_logic_vector(5 downto 0); signal S2 : std_logic_vector(5 downto 0); begin S1 <= ("00"&A) + ("00"&B); S2 <= ("00"&C) + ("00"&D); S <= S1 + S2; end comporte ;

Les parenthses sont obligatoires autour de la concatnation. On aurait pu raliser laddition sur une seule ligne de la manire suivante :

S <= ("00"&A) + ("00"&B) + ("00"&C) + ("00"&D);

On peut constater sur la simulation suivante que le rsultat S obtenu est correct.

3.3.4.4 Comparateur

La ralisation dun comparateur est assez vidente. Dans lexemple suivant, tous les signaux sont signs :

library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_signed.all;

113

entity comp is port( A : in std_logic_vector(3 downto 0); B : in std_logic_vector(3 downto 0); A_sup_B : out std_logic; A_inf_B : out std_logic; A_egal_B : out std_logic); end comp; architecture comporte of comp is begin process(A, B) begin if (A > B) then A_sup_B <= '1'; A_inf_B <= '0'; A_egal_B <= '0'; elsif (A < B) then A_sup_B <= '0'; A_inf_B <= '1'; A_egal_B <= '0'; else A_sup_B <= '0'; A_inf_B <= '0'; A_egal_B <= '1'; end if; end process; end comporte ;

Le rsultat de la simulation est le suivant :

-8 < 0

4 > -1

7=7

Pour raliser un comparateur non sign, il suffit de remplacer la ligne :


use IEEE.std_logic_signed.all;

par la ligne :
use IEEE.std_logic_unsigned.all;

Les rsultats de la simulation sont alors diffrents du cas prcdent : 114

8>0

4 < 15

7=7

Dans le cas dune comparaison dingalit, travailler en sign ou en non sign peut donner des rsultats diffrents.

Un pige traditionnel des comparaisons signes est illustr par lexemple suivant :

library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_signed.all; entity comp is port(A : in std_logic_vector(3 downto 0); flag_A : out std_logic); end comp; architecture comporte of comp is begin process(A) begin if (A > 7) then flag_A <= '1'; else flag_A <= '0'; end if; end process; end comporte;

Ce comparateur nest jamais activ en simulation et le synthtiseur ne gnre aucune porte logique pour ce design. En effet, A est cod en sign sur 4 bits et ne peut donc pas dpasser la valeur 7. La condition :

if (A > 7) then

115

nest jamais vraie et le signal flag_A est toujours gal 0. Mais si vous utilisez la std_logic_unsigned la place de la std_logic_signed, alors A peut aller de 0 jusqu 15 et la comparaison peut tre active. Le synthtiseur gnre alors un comparateur.
3.3.4.5 Multiplieur

La multiplication est un autre exemple de diffrence de comportement entre opration signe et non signe. Lexemple suivant est une multiplication signe 8 bits x 8 bits = 16 bits :

library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_signed.all; entity mult is port(A : in std_logic_vector(7 downto 0); B : in std_logic_vector(7 downto 0); Y : out std_logic_vector(15 downto 0)); end mult; architecture comporte of mult is begin Y <= A * B; end comporte ;

Le rsultat de la simulation est le suivant :

1x1=1

1 x -1 = -1

-1 x -1 = 1

En utilisant la std_logic_unsigned la place de la std_logic_signed, la multiplication devient non signe et la simulation donne les rsultats suivants :

1x1=1 116

1 x 255 = 255

255 x 255 = 65025

3.4

Exercices

Exercice 3.1 1. Quel est le nombre dcimal le plus petit et le plus grand que lon peut coder avec 4 bits, 8 bits, 16 bits, 32 bits, N bits en non sign et en CA2. 2. Convertissez (1101101)2 en dcimal. 3. Convertissez (19)10 et (45)10 et (63)10 en binaire. 4. Convertissez (11100101001010111)2 en hexadcimal. 5. Convertissez (10A4)16 et (CF8E)16 et (9742)16 en binaire et en dcimal. Exercice 3.2 Soient les quatre nombres hexadcimaux cods sur 8 bits suivants : 5516, C616, 1216, CB16 1. 2. 3. 4. Convertir ces nombres en dcimal en considrant quils sont non signs. Convertir ces nombres en dcimal en considrant quils sont signs. Convertir ces nombres sur 16 bits en considrant quils sont non signs. Convertir ces nombres sur 16 bits en considrant quils sont signs.

Exercice 3.3 1. Effectuer les oprations suivantes en limitant le rsultat quatre chiffres significatifs et en indiquant ltat de la retenue : 125310 + 725310, 234510 + 876510, 785410 234510, 234510 785410. Commentez les rsultats obtenus. 2. Effectuer les oprations suivantes (tous nombres sur 8 bits en CA2) : 5616 + 2C16, 5616 2C16, 2C16 5616, 8C16 2416, 2416 8C16. Vous indiquerez les valeurs des retenues C6 et C7 ainsi que de loverflow. Exercice 3.4 Lutilisation pour la transmission de donnes numriques dun code de 4 bits comme le code BCD ne permet pas la dtection dune simple erreur dinversion car le mot erron obtenu appartient gnralement au code utilis. Par exemple, en BCD, le mot (2)10 = (0010)2 transmis avec une inversion du troisime bit (gnr par un parasite sur la ligne) sera pris pour un (6)10 = (0110)2 la rception. Afin de rduire les erreurs de ce type, on utilise un code de dtection 117

des erreurs comme le code 2 de 5 qui reprsente les dix combinaisons possibles de deux 1 dans un mot de 5 bits. Le codage obtenu est le suivant :

Nombre dcimal b4 0 1 2 3 4 5 6 7 8 9 0 1 1 0 1 0 0 1 0 0

Code 2 de 5 b3 0 1 0 1 0 1 0 0 1 0 b2 0 0 1 1 0 0 1 0 0 1 b1 b0 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 1 1 1

On se propose de raliser un circuit combinatoire effectuant la conversion du binaire naturel en code 2 de 5 . 1. 2. 3. 4. Complter la table de vrit ci-dessus donnant le code en binaire nature a3 a2 a1 a0 correspondant chaque nombre dcimal. Dresser le tableau de Karnaugh de chacune des fonctions b4, b3, b2, b1, b0. Dduire des tableaux prcdents lexpression de chacune des fonctions et proposer une ralisation base de fonctions logiques lmentaires. Raliser b0 sous une forme qui nutilise que des portes NAND.

Exercice 3.5 On cherche raliser un montage permettant deffectuer laddition ou la soustraction sur 1 bit avec retenue entrante et sortante. 1. Etablir la table de vrit et le schma du demi-additionneur qui effectue lopration Si = Ai + Bi et qui calcule la retenue sortante.

118

Ai Bi

Demiadditionneur 1 bit

Si Ci

2.

En dduire la table de vrit et le schma de ladditionneur complet qui effectue lopration Si = Ai + Bi + Ci-1 et qui calcule la retenue sortante.

Ai Bi Ci-1

additionneur complet 1 bit

Si Ci

3. 4.

Mme questions 1 et 2 pour le soustracteur. En comparant ltage additionneur et ltage soustracteur 1 bit, proposer un montage unique qui, laide dune commande externe permet de raliser soit laddition, soit la soustraction.

Exercice 3.6 Analyser le circuit ci-dessous et dfinir son rle. a0 b0 a1 b1 a2 b2 a3 b3 F

119

Exercice 3.7 1. Donner limplantation dun comparateur 1 bit pourvu dune entre E autorisant la comparaison. Si E = 0, toutes les sorties valent 0, sinon le fonctionnement est le suivant :

Ai Bi E

comparateur 1 bit

Si Ei Ii

Si = 1 si ai > bi , 0 sinon. Ei = 1 si ai = bi, 0 sinon. Ii = 1 si ai < bi, 0 sinon. 2. Donner limplantation dun comparateur de deux nombres A = a2a1a0 et B=b2b1b0 en utilisant des comparateurs 1 bit et des portes OR.

120

4 Logique squentielle
Dans un circuit combinatoire, une sortie est uniquement fonction des entres. Par contre, dans un circuit squentiel, une sortie est une fonction des entres mais aussi des sorties du circuit. Il y a rebouclage (rtroaction) des sorties sur les entres. Cela signifie quun circuit squentiel garde la mmoire des tats passs. Il existe deux grandes catgories de circuit squentiel :
Le circuit squentiel asynchrone. Les sorties du montage peuvent changer tout moment

ds quune ou plusieurs entres changent aprs un temps de propagation qui peut tre diffrent pour chaque sortie.

circuit combinatoire (avec tats internes)

Le circuit squentiel synchrone. Le changement sur les sorties se produit aprs le

changement dtat (front montant ou descendant) dun signal matre, lhorloge. Les entres servent prparer le changement dtat, mais ne provoquent pas de changement des sorties. Tout changement dtat interne du montage est synchronis sur le front actif de lhorloge.

circuit combinatoire Horl (avec tats internes)

4.1

Circuits squentiels asynchrones

La forme la plus lmentaire de circuit squentiel, que lon appelle un latch (verrou), est la suivante :

121

Q0

Q 0 = s.Q1 = s + Q1 , Q1 = r.Q 0 = r + Q 0

Q 0 = s + r.Q 0 , Q1 = r + s.Q1

Q1

r
Sa table de vrit est :

s 0 0 1 1

r 0 1 0 1

Q0 interdit 1 0 Q0

Q1 interdit 0 1 Q1

Ltat 0,0 est interdit car il conduit un tat instable comme nous le verrons par la suite. Nous allons appliquer la mthode des tables dexcitation pour analyser dans le dtail le fonctionnement de ce circuit. Tout circuit logique asynchrone comportant des boucles de raction possde un fonctionnement squentiel. On peut modliser un circuit squentiel en ajoutant des retards dans les boucles de raction. Bien que les retards physiques, fonctions des temps de propagation travers les portes lmentaires, ne soient pas gaux, on convient de symboliser la fonction retard par une mme valeur pour ltude des circuits asynchrones.

circuit A B combinatoire idal

X2 X1

x2 x1

122

On dfinit :
Les variables primaires A et B. Ce sont les entres relles du circuit. Les variables secondaires (ou variable interne) x1 et x2. Ce sont les sorties rinjectes sur

lentre du circuit combinatoire idal.


Les variables dexcitation X1 et X2. Ce sont les sorties du circuit combinatoire idal sur

lesquelles a t plac un retard. Dans le cas du latch, on obtient le schma asynchrone quivalent :

Q0+

Q0

Q1+

Q1

r s r sont les variables primaires, Q0 Q1 sont les variables secondaires et Q0+ Q1+ sont les
variables dexcitation. On tablit la table dexcitation donnant Q0+,Q1+=F( s , r ,Q0,Q1) avec les quations combinatoires Q 0 = s.Q1 et Q1 = r.Q 0 .
+

rs

Q1 Q0 00
+ +

00 11 11 11 11

01 11 11 10 10

11 11 01 00 10

10 11 01 01 11

01 11 10

Q1 Q0

Puis on change de notation pour obtenir une table dtats internes :

123

s
0 0 1 1

r
0 1 0 1

notation 0 1 2 3

Q0 0 0 1 1

Q1 0 1 0 1

notation a b c d

La table dtats internes obtenue est :

rs

Q1Q0 a Q1 Q0
+ +

0 d d d d

1 d d c c

3 d b a c

2 d b b d instable Q1+ Q0+ Q1 Q0

b d c

stable Q1+ Q0+ = Q1 Q0

On voit que ltat interne (a) est toujours instable. A partir de ltat (b), on cherche sur la table des tats internes les effets de toutes les commandes, puis on recommence pour les tats (c) et (d). On obtient ainsi le graphe dvolution du montage.

1 3 2 b 2 2 0 d 0 3 a 1 0 c 1 3

124

En (d), si s r =3, on va en (a), tat instable. On a deux choix possibles : vers ltat b ou ltat c. Ltat choisi dpendra de la vitesse des portes (des valeurs de ), la porte la plus rapide passant 0 en premier. Dans un circuit squentiel, quand plusieurs changements dtats internes se produisent pour un seul changement sur les commandes, alors on dit quil se produit une race condition . Quand ltat final ne dpend pas de lordre des changements dtats internes, alors il sagit dune noncritical race . Quand ltat final du circuit dpend de lordre des changements dtats internes, alors il sagit dune critical race . Cest le cas pour le latch s r . Il faut toujours sassurer quaucune critical race ne peut se produire dans ce type de circuit squentiel avec rtroaction combinatoire car son comportement devient alors totalement imprdictible. Linterprtation du graphe est donc la suivante :
Ltat (d) est forc par 0 et gard en mmoire par 0. Ltat (b) est forc par 2 et gard en mmoire par 3 ou 2. Ltat (c) est forc par 1 et gard en mmoire par 3 ou 1. Les commandes sont quivalentes :

0. Commande interdite. On vite ainsi le problme d la commande 3 sur (d). On impose r.s = 0 lentre de la bascule, ce qui supprime la critical race . 1. Remise un tat (c). 2. Remise zro (RAZ) tat (b). 3. Mmoire. Le modle final du latch valable si r.s = 0 et son graphe dvolution sont :

Q+
s r

r.s = 0

2 3

Q=1 Q=0 2

Q=0 Q=1

3 1

avec lquation dexcitation : Q + = s + r.Q . On peut raliser une variante de ce latch avec des portes NOR, le latch RS :

125

R Q

Lquation ne change pas : Q + = S + R.Q avec R.S = 0. La table de vrit est : R 0 0 1 1 S 0 1 0 1 Q+ Q 1 0 X fonction mmoire mise 1 mise 0 interdit

Afin de saffranchir de ltat instable, on dfinit le latch JK de la manire suivante :

K J

R latch R-S S

On garantit de cette manire que ltat R = 1, S = 1 ne se produira jamais en posant R = K.Q et S = J.Q ce qui nous donne lquation de sortie suivante : Q + = J.Q + K.Q . La table de vrit vaut alors : J 0 0 1 1 K 0 1 0 1 Q+ Q 0 1 Q fonction mmoire mise 0 mise 1 inversion

Ltat instable du latch RS sest transform en un tat inversion. 126

4.2

Bistables synchroniss sur un niveau

Nous allons maintenant essayer de synchroniser le fonctionnement du latch avec un signal dhorloge laide du schma :
S

Q H

En respectant r.s = 0, on a Q + = s + r.Q , do on tire Q + = S.H + R.H.Q avec (R.H).(S.H) = R.S.H = 0. On obtient la table de vrit suivante :

R X 0 0 1 1

S X 0 1 0 1

H 0 1 1 1 1

Qn+1 Qn Qn 1 0 X

fonction mmoire mmoire mise 1 mise 0 interdit

Quand H vaut 1, le bistable fonctionne normalement. Quand H vaut 0, il garde en mmoire ltat antrieur. On appelle ce circuit un bistable RSH. Il est synchronis sur le niveau de lhorloge H. Il en existe une variante importante : le bistable DH (D pour delay, retard).

S R RSH

127

On pose S = D et R = D ce qui implique : D = 0 S = 0, R = 1 donc mise 0 et D = 1 S = 1, R = 0 donc mise 1. Ce bistable ne prsente plus de combinaison interdite d'entre car on a toujours R.S = 0. Il est appel latch transparent et ralise la fonction Q n+1 = H.Q n + H.D :
ltat copie, Qn+1= D pour H = 1. ltat verrou, Qn+1= Qn pour H= 0.

On nexploite Q que pendant la phase verrou. Cest l, la principale limitation des bistables. En effet, les montages suivants sont interdits :
Association synchrone en cascade. Ltat lentre de la chane se propage presque

instantanment sur la sortie (aprs un temps de propagation tp).


H E1 E2 E3 tP tP

E1

D H

E2

D H

E3

Rtroaction. Le montage oscille.


H

D H H

Q
Q

tP

Les latches transparents sont toujours utiliss dans les ASIC et dans les FPGA, mais il

est ncessaire de dfinir un nouveau circuit pour travailler en logique synchrone : cest la bascule.

128

4.3

Bascules D matre-esclave (master-slave D flip-flop)

Une bascule est un bistable qui ne change dtat quune seule fois par priode dhorloge. Le premier montage de ce type a t la bascule matre-esclave. Sa structure est la suivante :

Q Matre Q

Q Esclave Q

Q Q

HM

HE

En rglant habilement les seuils de basculement dhorloge du bistable matre et du bistable esclave, on obtient le chronogramme suivant :
H Seuil Matre Seuil Esclave HM

Lecture
HE

Verrou

La commande D est lue sur le niveau haut de H et elle est excute sur son front descendant. Cest donc une sorte de bascule synchronise sur front descendant. Ce type de bascule rgle les deux problmes vus au paragraphe prcdent, lassociation en cascade et la rtroaction. Toutefois, elle reste sensible aux parasites car la bascule matre accepte la commande pendant la totalit du niveau haut de lhorloge. On va donc dfinir un type de bascule qui naccepte la commande que pendant le front actif de lhorloge. Cependant, le montage maitre-esclave est encore utilis pour des raisons de processus de fabrication des circuits intgrs CMOS.

129

4.4

Bascules D synchronises sur un front (edge-triggered D flip-flop)

Ces bascules font lacquisition de la donne et ralisent la commande sur un front dhorloge. Ce sont les bascules actuellement utilises pour la conception en logique synchrone (avec les matre-esclave). Elles peuvent tre actives sur le front descendant ou sur le front montant de lhorloge.

D H

Q
Q

D H

Q
Q

Front montant

Front descendant

Dun point de vue purement thorique (il ne sagit pas du montage utilis rellement), on peut voir une bascule D commande par un front montant de la manire suivante :

D H H
tPCk

Q H

H H H
tPCk

Q r

En dosant de manire adquate le temps de propagation tPCK de linverseur, on obtient en H une impulsion juste assez large pour permettre le transfert de linformation D vers le latch RS. On voit bien avec ce montage que pour un fonctionnement correct de la bascule, la donne doit tre prsente un certain temps (setup) avant le dbut de limpulsion (le front actif) et rester stable un certain temps aprs (hold). Si la fentre de stabilit (setup+hold) nest pas respecte, un phnomne de mtastabilit apparat (4.6.4). La donne napparat sur la sortie Q quaprs un temps de propagation.

130

setup

hold

Qn
propagation

Qn+1

4.5

Bascules usuelles

Il existe quatre types de bascules usuelles :


La bascule RS. Son quation de sortie est Q n +1 = S + R.Q n avec S.R = 0. Son graphe

dvolution est :

SR=00 SR=01 0 SR=10

SR=00

La bascule RS synchrone nexiste pas sous la forme de composant discret et nest jamais utilise directement dans un montage. Toutefois, sa structure se retrouve dans toutes les autres bascules. Sous la forme du latch RS, elle sert raliser des interrupteurs antirebonds (voir exercice 4.1). On obtient la table de vrit :

R 0 0 1 1

S 0 1 0 1

Qn+1 Qn 1 0 X

fonction mmoire mise 1 mise 0 interdit

131

La bascule JK. Son quation de sortie vaut Q n +1 = J.Q n + K.Q n ce qui donne la table de

vrit :

J 0 0 1 1

K 0 1 0 1

Qn+1 Qn 0 1
Q n

fonction mmoire mise 0 mise 1

mmoire

Son graphe dvolution est :

JK=0X JK=1X 0 JK=X1

JK=X0

X est un tat indiffrent (dont care). Cette bascule permet la ralisation de montages ayant un minimum de portes combinatoires. Elle ncessite toutefois un cblage plus complexe quune bascule D car elle a deux entres alors que la bascule D nen a quune.

La bascule D (D flip-flop). Elle est obtenue en posant D = S = R avec une bascule RS ou

D = J = K avec une bascule JK, ce qui donne lquation Qn+1 = D et le graphe dvolution :
D=0 D=1 0 D=0 1 D=1

Sa table de vrit est :

132

D H 0 1

Qn+1 0 1

fonction mise 0 mise 1

Cette bascule existe sous forme de composant discret et permet la ralisation de montages ncessitant un minimum de cblage (car elle na quune entre) mais plus de portes combinatoires quavec des bascules JK. Toutefois, comme le problme du cblage est trs important dans les circuits intgrs rcents (alors que les portes logiques sont quasiment gratuites), la bascule D est la seule utilise (avec le latch transparent) dans les circuits programmables et dans les ASIC.
On peut noter une variante de la bascule JK, la bascule T (T flip-flop) pour laquelle on

pose J = K = T (T pour toggle). Son quation est Q n +1 = T Q n avec la table de vrit :

T 0 1

Qn+1 Qn
Q n

fonction mmoire

mmoire

Son graphe dvolution est :


T=0 T=1 0 T=1 1 T=0

La bascule T nexiste pas sous forme de composant discret car elle est trs facile raliser partir dune bascule JK ou dune bascule D. Elle est particulirement efficace dans la ralisation de compteurs binaires.
4.6 Caractristiques temporelles des circuits squentiels synchrones

Nous allons dfinir dans ce chapitre les intervalles de temps importants utiliss pour caractriser les circuits squentiels synchrones.

133

4.6.1 Dfinitions

Nous allons prendre l'exemple dune bascule D de type SN74LS74 :

SD D

CP CD

Les temps tudis pour cette bascule se retrouveront ( quelques variantes prs) dans pratiquement tous les autres circuits squentiels. Les signaux lentre dun circuit squentiel peuvent tre classs en deux catgories :

Les signaux action synchrone. L'entre D de la bascule est recopie sur les sorties Q et Q

aprs un temps de propagation tPLH ou tPHL au moment du front actif (ici le front montant) de l'horloge (note CK, CP ou H). La donne doit tre prsente sur lentre D un temps tSU (setup time) avant le front actif et tre maintenue un temps tH (hold time) aprs ce front. Limpulsion active de lhorloge (ici limpulsion positive) doit avoir une dure minimale tW (width time) pour tre prise en compte par la bascule. tSU D tW tH

CP Q

tPLH (CP to Q)

tPHL (CP to Q)

134

les signaux action asynchrone. Les signaux de mise 0 CD (reset ou clear) et de mise 1

SD (set) ont une action immdiate et prioritaire sur toutes les autres commandes. Ils ne sont pas synchroniss sur le front actif de lhorloge. Ces signaux sont actifs sur un niveau (ici le niveau 0). Tant que le niveau actif est maintenu, l'effet de la commande persiste. Le niveau actif de limpulsion doit avoir une dure minimale tW. Le dessin suivant donne un exemple de chronogramme pour le signal clear. Les temps de transitions ne sont pas reprsents.

CD Q

tW

tPHL (CD to Q)

Afin de voir immdiatement comment agit un signal, il est pratique de respecter la notation suivante :
le signal ayant un niveau actif 0 est nomm SIGNAL . le signal ayant un niveau actif 1 est nomm SIGNAL. le

signal

ralisant

deux

fonctions

(une

sur

chaque

niveau)

est

nomm

SIGNAL1/SIGNAL2 (comme par exemple le signal de lecture/criture R / W sur une

mmoire).

Remarque : comme nous lavons vu pour la logique combinatoire, les temps tPLH et tPHL sont gnralement gaux en technologie CMOS.

4.6.2 Calcul de la frquence maximale dhorloge dune bascule D

Il existe un autre paramtre utilis pour caractriser un circuit squentiel, la frquence maximale de fonctionnement fMAX. Ce paramtre est mesur, dans le cas dune bascule D, grce au montage suivant :

135

Clock

SD D Q D=Q Ck CD Q Q

Ce type de montage est appel montage toggle car la sortie change dtat chaque front actif dhorloge. La sortie Q est donc gale au signal dhorloge mais avec une frquence divise par 2. Agrandissons lchelle des temps pour faire apparatre les diffrents timings de la bascule : D=Q

> tH clock

> tSU TCK

> tH

> tSU

t Q tPHL tPLH

Pour que le montage fonctionne correctement, les paramtres du circuit doivent vrifier :

TH < min(tPHL, tPLH). Cette relation ne dpend pas de la frquence de lhorloge et elle

est toujours vrifie car on sarrange pour que le temps de maintien de la bascule soit nul en fabrication. Cette relation nintervient pas dans le calcul de la frquence maximale du circuit.

TSU < TCK - max(tPHL, tPLH). Cette relation dpend de la frquence dhorloge et elle

permet de calculer la frquence maximale du circuit. En effet, on remarque que pour un fonctionnement normal, la donne D doit tre prsente tSU avant le front montant de lhorloge. Or la donne D est gale la sortie Q qui apparat un temps tPHL ou tPLH (CP to 136

Q ) aprs le front montant de lhorloge. La priode de lhorloge Tck ne peut donc tre infrieure tSU + tP ou tp est le plus grand des temps de propagation clock to Q. Ce qui donne la relation : TCK > TSU + max(tPHL, tPLH). La frquence maximale de fonctionnement de la bascule (toggle rate) est donc dfinie par : 1 + max(t PHL , t PLH )

f max <

t SU

Hlas, la valeur de fmax nest pas toujours prise dans ces conditions dans les feuilles de caractristiques (data sheet) et la plus grande prudence simpose dans lexploitation de cette donne. Une lecture attentive des caractristiques constructeurs est ncessaire mais pas toujours suffisante pour dterminer la frquence maximale de fonctionnement dun circuit squentiel synchrone. Il faut aussi noter quen technologie CMOS, le temps de propagation de la bascule est le mme ltat haut et ltat bas : tPHL = tPLH = tp clock to Q.
4.6.3 Calcul de la frquence maximale dhorloge dans le cas gnral

Dans le cas gnral, un circuit logique squentiel synchrone peut toujours tre mis sous la forme de registres (N bascules D fonctionnant en parallle) relies par de la logique combinatoire :

Circuit logique combinatoire

D N registre

Q N

Circuit logique combinatoire

D N registre

Q N

clock

Certaines sorties de registres sont reboucles sur des entres. Il y a des entres pures et des sorties pures. Dans un montage rel, le nombre de bascules peut slever plusieurs dizaines ou centaines de milliers. Comment calcule-t-on la frquence maximale de fonctionnement dun tel monstre . En fait, cest trs simple. Il suffit de reprendre la formule vue

137

prcdemment et de lui ajouter le temps de propagation dans la logique combinatoire (tprop). On obtient donc :
1 + max(t PHL , t PLH )

f max <

t SU + t prop

ce qui traduit le fait que la donne doit tre stable tsu avant le front actif suivant de lhorloge. Toute la question est : quel temps de propagation combinatoire doit-on choisir ? On ne peut pas le calculer la main dans le cas gnral. Un outil de CAO va calculer tous les temps de propagation de toutes les sorties de bascules D vers toutes les entres de bascules D. Le chemin le plus long, le chemin critique, va donner le temps le plus long, le temps critique. Cest ce temps qui va dterminer fmax.
1 + t critique + max(t PHL , t PLH )

f max <

t SU

La frquence la plus leve dun montage de ce type est gale la frquence maximale de fonctionnement dune bascule D (qui ne dpend que de la technologie de fabrication utilise pour construire la bascule). Cest le cas o le temps critique est nul, ce qui implique que le montage ne ralise pas grand chose tant donn quil ne comporte pas de logique combinatoire. La frquence maximale dun montage rel est donc dtermine par le temps critique qui est fonction de la complexit du montage ralis et du talent de lingnieur qui conoit le circuit. Il est important de noter que ce raisonnement ne vaut que pour un circuit logique squentiel synchrone (il ny a quune seule horloge connecte toutes les bascules). Cest la premire raison pour laquelle on nutilise en pratique que ce type de montage dans les circuits logiques.
4.6.4 Mtastabilit

Il reste un problme que nous avons soigneusement vit jusqu maintenant. Que se passe-til si le montage ne respecte pas le temps de setup, cest--dire si la donne nest pas stable tsu avant le front actif de lhorloge ?

138

En fait, cest un problme trs courant que lon peut rencontrer dans deux cas : 1. Dpassement de la frquence maximale du montage. Il sagit l dune erreur dutilisation du composant. La solution est vidente : il faut respecter la fmax du montage. 2. Entres asynchrones. A partir du moment o le montage lit une donne extrieure avec une bascule D, il y aura forcment une violation du temps de setup un moment ou un autre. Par exemple, dans le cas dun bouton poussoir actionn par un oprateur humain ou bien dun capteur qui indique un dpassement de trop plein ou encore dune liaison srie (RS232) venant dun ordinateur. On ne voit pas trs bien comment un tre humain pourrait tre synchronis avec lhorloge du montage. On peut faire beaucoup dtudes savantes concernant le phnomne de mtastabilit. Ce phnomne intervient quand la bascule hsite changer dtat parce que la donne nest pas stable tsu avant le front actif de lhorloge. Elle se place alors dans un tat intermdiaire entre le 0 et le 1, ltat mtastable . En pratique, cela se traduit par un allongement du temps de propagation tp clock to Q de la bascule ; plus la violation du temps de setup est importante et plus le temps de propagation augmente. Bien sur, si la violation est trop importante, le changement en sortie na pas lieu.
D

t D H Q
t p H to Q

t 1 0
retard mtastabilit

Dans le cas des entres asynchrones, il est difficile de lutter contre la mtastabilit car il sagit dun phnomne physique naturel invitable. Il y a une erreur de base ne jamais commettre, cest la lecture multiple dune entre asynchrone :

139

Entre asynchrone

Q
Vers le montage squentiel synchrone avec clk

Entre asynchrone clk

Q
Vers le montage squentiel synchrone avec clk

D clk

MAUVAIS : une bascule peut lire correctement lentre et pas lautre. On peut avoir deux versions diffrentes de lentre dans le design.

BON : une seule bascule lit lentre. On aura deux versions identiques de lentre dans le design.

Une mthode simple et efficace pour lire une entre asynchrone consiste effectuer une double (voir triple) re-synchronisation. Cela permet de minimiser limportance du phnomne.

Entre asynchrone clock

Vers le montage squentiel synchrone

Elle est efficace condition que : 1. La frquence de lhorloge fclock ne soit pas trop leve (< 100 MHz). 2. La frquence de commutation de lentre fentre soit trs infrieure (10 fois) fclock. Si ces conditions ne sont pas respectes, les solutions suivantes sont possibles pour lire des donnes asynchrones : 1. fentre et fclock sont du mme ordre de grandeur, mais lchange de donnes est assez lent. On utilise un protocole dchange : le handshake. 2. Pour tous les autres cas, on utilise soit une mmoire double port, soit une FIFO.
4.6.5 Distribution des horloges : clock skew

Le bon fonctionnement dun montage squentiel synchrone repose sur une hypothse trs importante : le front actif de lhorloge arrive au mme moment sur toutes les bascules. En ralit, cest impossible raliser ( cause de la longueur des interconnexions par exemple) et il existe une incertitude sur larrive de ce front : cest le clock skew .

140

D1

Q1

D2

Q2

D3

Q3

clk1 clk clk

clk2

clk3

clk1

clk2

clk3

Clock skew

Heureusement, le clock skew ne concerne que les bascules adjacentes. Si les bascules affectes par ce phnomne sont spares par au moins une autre bascule, il ne peut y avoir de problme. Quelles peuvent tre les consquences du clock skew sur deux bascules adjacentes ? Deux cas sont possibles suivant le sens du dcalage :
Si clk2 arrive juste aprs Q1, il y a violation du temps de setup de la deuxime bascule.

D1

Q1

D2

Q2

clk1 clk D1

clk2

clk1

Q1

tP CK to Q

clk2

tsetup

141

Si clk2 arrive juste avant Q1, il y a violation du temps de hold de la deuxime bascule.

D1

Q1

D2

Q2

clk1 clk D1

clk2

clk1

Q1

tP CK to Q

clk2

Thold

Cette violation du temps de hold ou du temps de setup est trs gnante car elle ne peut tre limine en diminuant la frquence de fonctionnement du montage. Pour liminer ce problme, il faut que le clock skew soit faible devant le temps de propagation de la bascule. Au sens strict, il faut que : retard de clk2 sur clk1 < tp clock to Q tHold Si clk2 est un peu en avance sur clk1, il ny pas de consquence. En gnral, les diffrences dheures darrives entre les horloges sont dues aux dlais de routage du circuit intgr (diffrence des longueurs des interconnexions). Les horloges doivent subir un traitement spcial pour compenser les retards lintrieur du circuit. Dans un ASIC, on cre pour cela un
circuit de distribution dhorloge (ou arbre de distribution dhorloge).

Dans un circuit logique programmable, larbre de distribution des horloges est dj cr par le fabricant et il suffit de lutiliser en connectant lhorloge un buffer spcial (le buffer dhorloge, gnralement BUFG chez Xilinx). Lutilisation de ce buffer vous garantit le bon fonctionnement de lhorloge, cest--dire un clock skew qui ne gne pas le bon

142

fonctionnement du montage. Un synthtiseur efficace reconnait les horloges dun design et les connecte automatiquement au circuit de distribution dhorloge. Cest un point quil est prfrable de vrifier soigneusement car si le synthtiseur nutilise pas le buffer spcialis pour lhorloge, celle-ci sera route comme une donne et le clock skew ainsi cr aura de bonnes chances de perturber le fonctionnement de votre montage dune manire assez alatoire ( cause des violations de temps de setup et de hold qui ont tendance introduire des problmes de mtastabilit).
4.7 Rgles de conception

4.7.1 Influence des alas de commutation

Nous avons vu dans le chapitre sur la logique combinatoire que dans le cas gnral, il peut se produire un ala de commutation (un glitch) en sortie de tout montage combinatoire sauf si celui-ci a fait lobjet dune conception hazard-free extrmement contraignante. Quelle va tre linfluence de ce glitch dans un montage squentiel ? Prenons un exemple simple :

D s 1 T0 H H
H tP1 tP2

Q Q

Q0

T1 H

Q1

Q0 Q1 s

activation bascule souhaite

parasites

Sur cet exemple, on voit bien limpulsion parasite (le glitch) apparatre la sortie de la porte OR. Il est d la diffrence de temps de propagation (clock to Q) entre les deux bascules T. 143

Sa dure est indpendante de la frquence de fonctionnement et totalement dpendante du processus de fabrication des bascules. Certains couples de bascules ne provoqueront pas de parasites, dautres le feront. Si le signal S est utilis pour attaquer lentre dhorloge dune bascule, le glitch risque dtre vu comme un front supplmentaire et dactionner la bascule. La seule solution efficace pour viter ce genre de problme est dutiliser la logique squentielle synchrone.
4.7.2 Rgles de conception synchrone

Les circuits squentiels synchrones sont constitus de bascules synchronises sur les mmes fronts dune seule horloge spares par des couches de logiques combinatoires. Toutes les commandes sont prises en compte sur le front actif de lhorloge et les hazards , sil y en a, sont forcment termins sur le front actif suivant de lhorloge (si bien entendu le montage respecte la frquence maximale de fonctionnement). Dautre part, il ne peut y avoir de race condition puisquil ny a pas de rtroactions combinatoires directes mais seulement des rebouclages sur les entres des bascules. Le fonctionnement dun circuit en logique synchrone est donc extrmement fiable et portable dune famille technologique lautre. De plus, sa vitesse augmente linairement avec laccroissement de la vitesse des lments qui le composent. Lamlioration de la densit dintgration conduit donc automatiquement une augmentation des performances.

Par construction, en logique squentielle synchrone, les alas de commutation peuvent tre ignors en toute scurit car ils sont forcment termins avant le front actif suivant de lhorloge. Cest une autre raison (avec le calcul de fmax) pour laquelle on nutilise en pratique que ce type de montage dans les circuits logiques.

Toutefois, il est ncessaire pour viter tout problme de respecter certaines rgles : 1. Il ne faut pas attaquer une entre dhorloge avec une combinaison de sorties de bascules. Dune manire plus gnrale, il faut traiter sparment le chemin des donnes et les lignes dhorloge. 2. Il ne faut pas utiliser les entres asynchrones dune bascule (entre Clear et Preset par exemple) pour raliser une raction. Il est dailleurs conseill de navoir que des entres synchrones sur les bascules.

144

4.7.3 Le rle du CE

Il reste toutefois un problme dont nous navons pas parl. Si toutes les bascules sont actives par la mme horloge, comment peut-on inhiber une bascule ou si vous prfrez comment empcher la copie de D sur Q sur le front actif de lhorloge ? Il manque pour cela une entre de validation sur nos bascules. Cest lentre CE ou Chip Enable . Sans cette broche supplmentaire, il est impossible de raliser un montage squentiel synchrone.

D CE H

Son fonctionnement est trs simple : 1. CE = 1 Qn+1 = D sur le front actif de lhorloge. 2. CE = 0 Qn+1 = Qn sur le front actif de lhorloge. En ce qui concerne la ralisation interne, il suffit dajouter un multiplexeur 2 vers 1 command par CE sur lentre D dune bascule pour obtenir :

CE D clock

Nous pouvons maintenant reprendre et corriger le montage prcdent :

145

D s 1 T0 H H
H tP1 tP2

Q0

T1 H

Q1

CE

Q Q

parasites

Q0 Q1 s

activation bascule

Lquation logique de s a chang, mais la sortie du montage reste la mme (vous pouvez vrifier que la bascule est active au mme moment). Les hazards sont toujours l, mais il ne nous gne plus.
4.7.4 Asynchrone contre synchrone

En rsum, la logique squentielle synchrone a les avantages suivants : 1. Fiabilit car les alas de commutation ninterviennent pas dans le fonctionnement du montage. 2. Calcul simple de la frquence maximale de fonctionnement du montage grce la formule suivante. Les outils de CAO savent calculer le temps critique du montage.
1 + t critique + max(t PHL , t PLH )

f max <

t SU

3. portabilit dune famille technologique lautre. 4. La frquence augmente linairement avec laccroissement de la vitesse des lments qui composent le montage. Lamlioration de la densit dintgration conduit donc automatiquement une augmentation des performances.

146

Comment dfinir la logique squentielle asynchrone ? On la dfinit plutt par opposition la logique squentielle synchrone. Tout montage qui ne respecte pas strictement les rgles de conception synchrone est asynchrone. Pour le dbutant, cest hlas la solution qui vient en premier. Elle est gnralement caractrise par labsence dhorloge matresse et/ou par la prsence de rebouclage squentiel asynchrone. Lorsquelle est utilise dans les rgles, cest-dire lorsquelle est conue correctement et de manire fiable (cest--dire quasiment jamais
sauf par des ingnieurs trs expriments : il faut savoir que les outils de CAO marchent trs mal en asynchrone, ce qui ne facilite pas la conception), elle a les avantages suivants :

1. Frquence de fonctionnement plus leve quen logique synchrone ; 2. Consommation plus faible quen logique synchrone frquence de fonctionnement identique.

Pour toutes ces raisons, depuis le dbut des annes 80, tous les montages correctement conus utilisent la logique squentielle synchrone.

4.7.5 Le reset

Dans le cas gnral, il est important quun montage squentiel synchrone dmarre dans un tat connu. On utilise gnralement pour cela un signal de mise 0 ou reset qui consiste mettre 0 toutes les sorties Q des bascules D du montage. En ralit, on devrait parler dun signal dinitialisation qui peut charger indiffremment un 1 ou un 0 dans une bascule. Le signal reset existe sous deux formes :
Synchrone (prioritaire sur D).
D Q

clk clk Reset synchrone

reset

tsetup + thold

tp clk to Q

147

La ralisation dune bascule D avec un reset synchrone ne pose pas de problme particulier. Il suffit dajouter un AND sur lentre D comme sur le schma suivant.
Reset synchrone prioritaire D Q

clk

Nimporte quelle bascule peut tre quipe dun reset synchrone qui est vu comme une donne et sera rout comme tel. Le chemin critique sera bien sur allong et la frquence maximale de fonctionnement de la bascule baissera.
Asynchrone (prioritaire sur toutes les autres entres).

clk clk Reset asynchrone

reset

tp reset to Q

Le reset asynchrone doit faire partie du design de base de la bascule D, au moment de sa conception. Il est impossible de le rajouter aprs coup si la bascule na pas t conue avec. Pour savoir sil existe, notamment dans un circuit logique programmable de type EPLD ou FPGA, il faut tudier attentivement la documentation sur le fonctionnement des bascules. 148

Quel reset utiliser ? Au vu du paragraphe 4.7 sur les rgles de conception synchrone, la

question du choix du reset semble vidente. Il faut utiliser un reset synchrone qui sera considr par loutil de synthse comme une donne et qui sera analys par lanalyseur de timing de la mme manire. La seule consquence prvisible, cest plus de portes logiques combinatoires sur les entres des bascules D du montage et donc plus de longueur de routage, cest--dire une frquence de fonctionnement plus faible. Cette rponse vidente est vraie pour les ASICs, mais moins vidente pour les FPGA/EPLD. En effet, ces circuits subissent la mise sous tension une configuration binaire qui est suivie gnralement dun reset asynchrone automatique. Il existe dans un FPGA (par exemple chez Xilinx) des ressources de routage ddies qui sont relies tous les lments de mmorisation du montage (y compris donc les bascules D). Cest le Global Set Reset (GSR) chez Xilinx. Cest lactivation du GSR la mise sous tension qui initialise les bascules D et les blocs mmoires du design. Si vous ne spcifiez pas de valeurs dans le code VHDL, la valeur 0 est copie par dfaut dans tous ces lments. Vous pouvez utiliser le GSR dans votre design condition dutiliser un reset asynchrone. Le synthtiseur dtecte tous les reset asynchrone du montage, les relie ensemble puis les connecte au GSR ( laide dun composant Startup comme nous le verrons en TP). Cette ressource GSR qui existe dans le FPGA est gratuite et ne consomme ni porte logique ni ressources de routages utilisateur. Elle na donc pas dinfluence sur la frquence de fonctionnement du design. Evidemment, il sagit dun set/reset asynchrone qui ne peut pas tre fonctionnel dans le design. Peut-on lutiliser quand mme ? Il y a plusieurs aspects considrer : 1. La simulation fonctionnelle/post-layout. Un signal de type std_logic non initialis dans un design dmarre ltat U (Unknown = inconnu), ce qui reflte lide que ltat de sortie dune bascule est indtermin la mise sous tension. Pour donner un tat connu aux bascules D dun montage, un reset asynchrone est largement suffisant. On active le reset au temps 0 pendant quelques dizaines de nanosecondes, on dsactive puis on dmarre les autres signaux tels que les horloges. Cela reflte lactivation du GSR la mise sous tension du FPGA. 149

2. Dans le FPGA. Le problme vient du fait que le temps de propagation du GSR dans le circuit nest nullement garanti. Il peut y avoir une grande incertitude (plusieurs ns) dans lheure darrive du signal sur les lments de mmorisation du circuit. A lactivation du GSR, aprs un temps de propagation inconnu, tous les lments sont initialiss. Jusque l, tout va bien. Mais au moment o on dsactive le GSR (donc la fin du reset), toutes les bascules ne seront pas relches en mme temps. Certaines parties du design vont dmarrer avant les autres puisque gnralement les horloges sont actives en permanence.
Toutes les bascules sont initialises Dbut du relchement des premires bascules Fin du relchement des dernires bascules GSR

PROBLEME

Incertitude sur lheure darrive du GSR sur toutes les bascules D du FPGA

Cela peut poser un problme fonctionnel pour certains montages tels que les filtres rcursifs ou bien les contrleurs dans les machines dtats, en fait dans tous les montages o il y a rebouclage synchrone des sorties sur les entres. Par contre, les montages sans rebouclage tel que les filtres non rcursifs ne sont pas affects par le problme car les fausses valeurs du dmarrage sont limines rapidement par de nouveaux chantillons traiter.

Remarque : il faut bien comprendre que le GSR sera activ dans tous les cas la mise sous tension. Certaines personnes croient, tort, que sils nutilisent que des reset synchrones, ils nont pas se proccuper du GSR. Grossire erreur : si votre montage ne supporte pas un reset asynchrone, il ne dmarrera pas correctement.

150

La rgle finale est assez simple noncer, mais pas toujours vidente respecter :
On peut utiliser un reset asynchrone dans un design condition quil ne soit pas fonctionnel, cest--dire que le montage marche quelques soient les valeurs des bascules au dpart. Si ncessaire, on cre un reset synchrone pour les parties sensibles du design.

Il faut aussi savoir quil existe dans les FPGA de plus en plus de parties spcifiques qui ne fonctionnent quavec un reset synchrone. Si vous essayez dutiliser ces composants associs un reset asynchrone, le synthtiseur refuse de les infrer. Quelques exemples chez Xilinx :
Registre 36 bits associ au multiplieur dans la Spartan-3, SRL16 dans les familles Spartan et Virtex, Bloc DSP dans la Virtex.
Comment crer ce reset synchrone fonctionnel ? Par exemple en utilisant un compteur qui

est initialis automatiquement par le GSR au dmarrage et qui va compter jusqu N. Quand il atteint cette valeur, il dlivre une impulsion pendant une priode dhorloge (cest le signal reset synchrone) puis il sarrte de compter. Exemple avec N = 10 :
Reset asynchrone connect automatiquement au GSR GSR

Compteur 4 bits Q clk CE 4

Comparateur 4 bits Q = 10 Q < 11 Reset synchrone

clk

reset

Nous naurons pas besoin dutiliser ce montage dans ce cours car nos montages ne sont pas assez complexes. Nous utiliserons un reset asynchrone, ce qui permettra de simuler le fonctionnement correctement. Ce reset sera reli un bouton poussoir sur la maquette. Le cas chant, nous crerons un reset synchrone en fonction de nos besoins.

151

4.8

Circuits lmentaires

4.8.1 Les bascules lmentaires

Parmi les bascules que nous avons tudies prcdemment, seuls les deux modles suivants sont encore utiliss dans les ASICs et dans les circuits logiques programmables :

appellation

notation

preset

D flip-flop synchrone sur front dhorloge

D CE CK

clear

Latch transparent D

Q OE

On peut encore trouver la fonction 7474 en technologie CMOS dans un boitier 14 broches (Small Outline), mais elle est en voie de disparition rapide. La fonction latch nexiste plus sous forme discrte.

4.8.2 Le registre

Un registre est lassociation en parallle de plusieurs bascules D identiques. On parle par exemple dun registre 16 bits (compos de 16 bascules D identiques relies en parallle). Un registre N bits peut tre vu comme une bascule D qui traiterait des mots binaires de N bits. Il permet de stocker un mot de N bits. Voici un exemple de registre 4 bits :

152

D0

Q0

D1 4 D clk Q D2 4

Q1

Q2

Registre 4 bits D3 Q3

clk

Les caractristiques temporelles du registre sont celles de la bascule D qui le compose. On trouve encore des registres en technologie CMOS sous forme discrte. Par exemple la fonction 74374, registre 8 bits, est toujours commercialise en technologie CMOS 2,5 V et on en trouve sur toutes les cartes mres de PC.
4.8.3 Le registre dcalage
4.8.3.1 Dfinition

Un registre dcalage est une association en cascade de bascules D permettant de dcaler gauche ou droite une srie de bits de donnes. Lexemple suivant montre un registre dcalage lmentaire sur 4 bits avec entre srie et sorties parallles :

Entre srie clk

D0

Q0

D1

Q1

D2

Q2

D3

Q3

153

Dans un modle plus labor, on peut trouver une entre de donnes en srie, N entres de chargement en parallle et N sorties. La Nime sortie peut servir de sortie srie.
entres // entre srie horloge
P0 Q0 PN-1

chargement
QN-1

sortie srie

Il y a trois principaux modes dutilisation : 1. Lentre srie avec sortie parallle. Prenons un exemple avec un registre 4 bits et voyons lvolution des donnes en sortie. A chaque coup dhorloge, la donne sur lentre srie est copie sur ltage 0 et la donne se trouvant ltage i-1 est transfre ltage i. Ainsi, les donnes rentres en srie sont mises en parallle sur les sorties.

entre srie b0 b1 b2 b3 b4

Ck

Q0 b0 b1 b2 b3 b4

Q1 0 b0 b1 b2 b3

Q2 0 0 b0 b1 b2

Q3 0 0 0 b0 b1

2. Lentre parallle avec sortie srie. Prenons un exemple avec un registre 4 bits et voyons lvolution des donnes en sortie. Sur le front actif de lhorloge avec lentre de chargement 1, les donnes parallles sont copies sur les sorties. Ensuite, chaque coup dhorloge, la donne se trouvant ltage i-1 est transfre ltage i et un 0 est copi sur ltage 0. On voit apparatre sur la sortie srie Q3 les donnes parallles mises en srie.

chargement 1 0 0 0

Ck

Q0 P0 0 0 0

Q1 P1 P0 0 0

Q2 P2 P1 P0 0

Q3 P3 P2 P1 P0

154

3. Lentre srie avec sortie srie. On reprend le tableau du mode 1, mais on considre les donnes sortant sur Q3. Ce sont les donnes de lentre srie apparaissant aprs un retard de 4 coups dhorloge.
4.8.3.2 Applications

Les registres dcalage ont de nombreuses applications. Parmi celles-ci, on trouve :


La conversion de donnes srie-parallle utilise pour la transmission de donnes. On

prend des bits en srie et on les convertit (gnralement sur un octet) en parallle.
La conversion de donnes parallle-srie utilise pour la transmission de donnes. On

prend des donnes binaires (gnralement un octet) en parallle et on les convertit en un train binaire srie.
Les oprations arithmtiques pour raliser des multiplications et divisions (oprations

utilisant le dcalage). On entre et on sort alors en parallle.


Les compteurs en anneau (entre srie, sortie srie). Il faut effectuer un chargement initial,

puis chaque coup d'horloge le contenu se dcale en suivant une permutation circulaire. On peut raliser des gnrateurs d'horloges dcales (code Johnson), des chenillards, ...

Entre srie Ck Registre reboucl

100000000000 010000000000 001000000000 000100000000 etc. 000000000001

4.8.3.3 Le SN74LS178, registre dcalage polyvalent de 4 bits

Finissons ce paragraphe avec un exemple de registre dcalage du TTL data book, le SN74LS178. Il ny a plus de registre dcalage de ce type commercialis, mais la fonction ralise est intressante tudier. C'est un registre dcalage entres parallles, sorties parallles, entre et sortie srie. 155

P0 Donne Srie H SE PE DS CP

P1

P2

P3

Entres parallles

sorties parallles Q0 Q1 Q2 Q3

Sortie srie

Le plus souvent, dans les registres dcalage, les bits gauche ont les poids les plus faibles. Cette notation peut tre gnante, mais c'est celle des circuits que l'on trouvait dans le commerce. Les signaux SE et PE slectionnent 3 types de fonctionnement possibles :

SE H L L

PE X H L

CP

Action dcalage : DS Q0 Q1 Q2 Q3 chargement : Pi Qi pas d'action

Le registre est form de 4 bascules D. D'aprs le tableau ci-dessus, on peut crire immdiatement l'quation au niveau de lime tage : Di = SE.Qi 1 + SE.PE.Pi + Qi.SE.PE D'o le schma suivant pour l'tage i :
Pi : Entre parallle de l' tage

SE.PE Qi-1 SE SE.PE Ck

Di

Qi

Etage i

156

4.8.4 Les compteurs


4.8.4.1 Introduction

La fonction comptage est lune des plus importantes de llectronique numrique. Rares sont les designs qui nen comportent pas un grand nombre. Le principe est simple : chaque coup dhorloge, la sortie dun compteur est incrmente. La squence de sortie pour un compteur N bits va donc voluer de 0 2N-1, puis repasse 0 et reprend le cycle. Lexemple suivant montre le graphe dvolution dun compteur 3 bits :

reset

Q0 CE Clk Q1 Q2 Compteur 3 bits 6 2

5 4

Le chronogramme ralis est donc le suivant :


clk

reset

CE

Q U 0 1 2 3 4 5 6 7 0 1 2 3

157

Il existe deux familles de compteurs : 1. les compteurs synchrones : toutes les sorties changent d'tat un temps tP clock to Q aprs le front actif de lhorloge. 2. les compteurs asynchrones : la sortie N change dtat un temps tP clock to Q aprs la sortie N1, la sortie 0 change dtat un temps tP clock to Q aprs le front actif de lhorloge (aucune sortie ne change en mme temps que les autres). On utilise principalement des compteurs binaires N bits (modulo 2N) ou dcimaux (par dcades). On peut aussi raliser des compteurs de type Gray ( partir dun compteur binaire, voir 3.1.4.2), one hot ou Johnson (avec un registre dcalage). Ces compteurs peuvent possder des fonctions supplmentaires telles que :
La remise zro de ltat du compteur. Le chargement parallle. Cette entre permet de charger en parallle une valeur dans le

compteur, cette valeur devant tre prsente sur les entres de chargement parallle.
Le dcomptage. Au lieu dincrmenter la sortie du compteur chaque front dhorloge, on

la dcrmente. La squence devient donc (pour un compteur binaire) : 2N-1, 2N-2, , 0, 2N1

, 2N-2,

la retenue (aussi appele CEO pour Chip Enable Output ou encore RCO pour Ripple Carry

Output) qui indique le dpassement de capacit et sert mettre les compteurs en cascade.
Lentre de validation CE pour autoriser le comptage ou mmoriser la valeur prcdente.

Les entres peuvent tre actives 0 ou 1 et tre action synchrone ou asynchrone.


4.8.4.2 Compteurs binaires asynchrones et synchrones

Les compteurs asynchrones, qui ne sont plus commercialiss, peuvent toujours tre utiliss comme fonction dans un circuit logique. Leur principe de fonctionnement est le suivant :
Q0 Q1 Q2 Q3

T0

Q0

T1

Q1

T2

Q2

T3

Q3

ck

158

Cet exemple ralise un comptage de 0 15 puis retour 0 puisque, pour chaque bascule T, Qn+1 = Q n . Les temps de propagation tP Ck to Q s'ajoutant, un dessin en haute frquence montre des tats transitoires de commutation :

tP CktoQ Ck tP CktoQ

Q0 Q1

Q2

N d'tats

2 0

tats parasites transitoires

Si la frquence augmente, les tats transitoires peuvent durer plus longtemps que les tats rels du compteur. Toutefois, si on ne ralise qu'une division de frquence, ils ne sont pas du tout gnants, et on obtient alors la structure de diviseur de frquence la plus rapide car la frquence maximale du compteur est gale la frquence maximale de la bascule de poids faible. De plus, ce montage consomme moins que son quivalent synchrone car chaque bascule fonctionne la frquence minimale possible pour raliser la fonction. Par contre, on ne peut exploiter les tats de sortie du compteur que quand ils sont stabiliss, ce qui en limite fortement lusage. Il faudra compter sur un front et chantillonner les sorties par une bascule D active sur l'autre front (dans le cas o la somme des tP ck to Q ne dpasse pas la demi-priode de lhorloge). Malgr cela, on atteint trs rapidement les limites utilisables. Par exemple, si on augmente trop la frquence dun compteur 4 bits, on peut obtenir le chronogramme suivant :

159

CK

Q0

Q1 Q2 Q3

7 ETATS VOULUS

tats parasites

Comme il est impossible dexploiter les tats de sortie de ce compteur cette frquence, il faut passer en logique synchrone avec un schma du type :

T0

Q0

T1

Q1

T2

Q2

T3

Q3

ck Q0 Q1 Q2 Q3

Toutes les sorties du compteur changent un temps tP ck to Q aprs le front actif de lhorloge. Il ny a plus dtats parasites transitoires. Par contre, pour une simple division de frquence, ils sont moins performants que les compteurs asynchrones car la frquence maximale dutilisation est plus faible : 1 t P Ck to Q + t setup + t P logique combinatoire

f max =

160

Le chronogramme de sortie est donc :

Tp Ck to Q

Ck

Q0 Q1

Q2

N d'tats

Ces deux montages montrent bien les diffrences entre logique synchrone et asynchrone. Le tableau suivant rsume leurs caractristiques :

type asynchron e synchrone

frquence maximale fmax bascule T


1 + t setup + t P AND

consommation avec N tages 1++ +=2 1+1+1+=N

exploitation des sorties trs difficile en gnral aprs le temps tp ck to Q

utilisation diviseur dhorloge universelle

t P Ck to Q

4.8.4.3 Ralisation des fonctions supplmentaires

Elles sont ralises partir de bascules D, avec un rebouclage adquat de Q sur D. Les chargements synchrones, remises zros asynchrones ou synchrones sont effectus par le circuit suivant (tage i) :

161

Ei Entre parallle de l' tage

Clear asynchrone Clear synchrone

Di
clr

D Ck

Qi

Qi Etage N i Load synchrone Ck

4.8.4.4 Mise en cascade de compteurs

Nous naborderons ici que la mise en cascade des compteurs synchrones. La question qui se pose est : comment former un compteur plus grand en associant plusieurs compteurs identiques plus petits ? La question se pose par exemple lorsque que lon veut compter en dcimal. Exemple : on va utiliser plusieurs compteurs BCD (qui sont cods sur 4 bits) et les associer pour former un compteur qui compte de 0 999 :

CEO Cnt2 ck Q11

CE

CEO Cnt1

CE

CEO Cnt0

CE

Q8

Q7

Q4

Q3

Q0

Nous avons besoin de trois compteurs BCD. La sortie CEO doit valider le compteur de poids plus lev au bon moment pour le coup d'horloge suivant. Quel est le bon moment ? Il faut pour rpondre cette question reprendre la squence de comptage :

162

CEO2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Cnt2 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1

CEO1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0

Cnt1 0 0 0 0 1 1 8 8 9 9 9 9 0 0 0 0 1

CEO0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0

Cnt0 0 1 8 9 0 1 8 9 0 1 8 9 0 1 8 9 0

On constate sur la squence que :


Cnt0 est activ en permanence donc CE premier tage = 1. Cnt1 est activ quand Cnt0 = 9 via CEO0. Cnt2 est activ quand Cnt1 = 9 et quand Cnt0 = 9 via CEO1.

Du fonctionnement de cnt1, on pourrait dduire htivement que CEO vaut 1 quand le compteur atteint la valeur 9. Cest vrai pour cnt1 mais faux pour cnt2. En effet, on voit que CEO1 = 1 quand cnt1 = 9 et quand son CE = 1, cest--dire quand cnt0 = 9.

On incrmente la dcade suprieure quand toutes les dcades infrieures ont atteint 9, donc CEO = dtection de la valeur finale de comptage AND CE

Le CEO du compteur BCD est donc ralis de la manire suivante :

163

Dtection valeur finale = 9 Q0 Q1 Q2 Q3 CE CEO

Ce rsultat peut tre tendu aux autres familles de compteurs. Seule la valeur finale dtecte change.
4.8.4.5 Ralisation de compteurs modulo quelconque.
4.8.4.5.1 Action sur l'entre Clear synchrone

Lorsque ltat final du compteur est dtect, le front actif suivant de l'horloge remet zro le compteur. Une dtection incomplte est possible et mme souhaitable pour limiter les alas, elle consiste ne dtecter que les bits 1. Dans lexemple suivant, on ralise un diviseur par 6 en dtectant ltat 5, puis en rinitialisant le compteur au coup dhorloge suivant. Les tats en sortie seront donc 0, 1, 2, 3, 4, 5, 0, 1, ...

Clear synchrone

Compteur binaire synchrone avec clear synchrone D C B A F/6

Bien que le compteur soit synchrone, de petites dispersions dans les tP ck-to-Q peuvent fournir un tat parasite transitoire. Ces alas ne sont pas forcment gnants, nous allons les tudier cidessous.

164

4.8.4.5.2 Rappel des cas possibles d'alas

Un ala peut survenir lorsque deux entres d'une porte lmentaire changent d'tat peu prs en mme temps. Si les temps de transitions sont voisins du temps de traverse de la porte, on a trois possibilits :

Signal1 Signal2
Cas 1 Signal 1 Cas 2

Sortie
Cas 3

Signal 2 Sortie

ATTENTION

Dans le cas particulier de cette NAND, le cas n1 provoquera systmatiquement un parasite 0 car la transition 0-1 sur le signal 1 fait changer la sortie (avec signal 2 1). Par contre, le cas n2 ne provoquera jamais dala puisque la transition 1-0 sur le signal 2 ne fait pas changer la sortie (avec signal 1 0). Quand au cas n3, tout dpendra des caractristiques relles de chaque porte. Certaines portes produiront un ala, dautres non.
4.8.4.5.3 Influence de lala

Reprenons lexemple du diviseur par 6. L'ala peut exister en sortie de la porte NAND dtectant l'tat 5, au passage de l'tat 3 l'tat 4. Sur une entre synchrone de remise zro, cet ala n'a pas d'action car il ne se produit pas sur le front actif de lhorloge. Avec un clear synchrone, les alas de commutation nont aucun effet. L'tude de ce type de montage sen trouve grandement facilite. Par contre, si on utilise un clear asynchrone, alors lala au passage de ltat 3 ltat 4 peut remettre le compteur 0. Cela dpendra de sa dure et de la rapidit du compteur. Il est donc interdit dutiliser un clear asynchrone pour raliser un diviseur par N. Comme nous lavons dj vu, il ne faut jamais utiliser comme horloge d'un compteur ou dune bascule une combinaison logique de sorties dun compteur. Des impulsions parasites (des glitches) se trouveront sur ce signal et seront prises pour des fronts dhorloge 165

supplmentaires. Par contre, en utilisant une sortie de bascule (comme dans notre exemple), vous avez la garantie dun signal sans ala de commutation. La largeur de ces glitches dpendra uniquement des temps de propagation du compteur (clock to Q) et de la rapidit de la porte mais pas de la frquence de fonctionnement. Lobservation du glitch est trs dlicate et il est difficile de lobserver sans savoir o il se trouve. Si par exemple, on a le chronogramme suivant la frquence de 100 MHz :

Horloge Sortie du NAND

tat 4

tat 5

A 100 kHz, on aura un parasite de mme largeur mais il ne sera pratiquement plus visible quoique toujours actif.

5
Horloge Sortie du NAND

Parasite pratiquement invisible

Si vous ne le cherchez pas, vous aurez du mal le trouver. De plus, il faut un oscilloscope performant pour pouvoir lobserver. Une formule est connatre : tmonte = 0.35 . bande passante

Elle signifie quil faut un oscilloscope bande passante leve pour pouvoir observer un ala court, par exemple 3.5 GHz pour un ala dune dure de 100 ps. Mme si vous savez o il se trouve, lobservation dun glitche rapide ncessite du matriel performant et donc coteux. La frquence maximale de fonctionnement (pour lexemple du diviseur par 6) est dtermine par le temps sparant le changement dtat en sortie de la NAND et le front actif suivant de lhorloge.

166

tat 4 Horloge

tat 5

tp porte Tsetup Clear

Sortie du NAND

tP Ck to Qi

On dduit de ce chronogramme la frquence maximale du compteur :


Fmax = 1 t ck to Qi max + t p porte max + t setup Clear min

4.8.4.5.4 Action sur lentre LOAD synchrone

En mode comptage, au moment du passage de ltat 2n-1 ltat zro, le compteur fournit un signal de retenue CEO . On l'utilise pour charger une valeur qui servira de valeur initiale dans la squence. Lexemple suivant reprend le diviseur par 6 mais avec en sortie les tats 10, 11 ,12 ,13, 14, 15, 10, 11,
1 0 1 0 10 entres parallles

P3 P2 P1 P0 Load

CEO

Q3 Q2 Q1 Q0 sorties

Frquence F/6

4.8.5 Laccumulateur de somme

Laccumulateur de somme permet de raliser une somme multiple raison dun coup dhorloge par terme sommer.

167

14

Equation ralise : Somme = X i


i =1

14 D clk Q 14

Si

Exemple dutilisation : calcul dune moyenne mobile

Somme

Il est compos dun additionneur N bits suivi dun registre N+k bits. Le paramtre k dpend du nombre de valeur N bits sommer sans quil y ait dbordement. Prenons un exemple avec N = 8 bits et 64 valeurs additionner, c'est--dire que k = 6 bits (laddition de 64 valeurs 8 bits tient sur 14 bits, donc k = 14 8 = 6 bits). Le chronogramme de fonctionnement est le suivant (on prsente X sur le front descendant de lhorloge, registre mis 0 au dmarrage) :
clk

reset

X 0 Si U Somme U 0 1 3 6 10 15 0 1 2 3 5 6 9 10 14 15 20 1 2 3 4 5

Le registre doit tre initialis 0 au dbut du calcul de la somme. Il faut utiliser un reset

synchrone car ce reset est fonctionnel. 168

4.8.6 Laccumulateur de produit : MAC

Laccumulateur de produit (MAC : Multiplier ACcumulator) est un accumulateur de somme prcd dun multiplieur sur lentre X.
A 16 P 16 B

32

36

Equation ralise : Q =

A .B
i =1 i

36 D clk Q 36 Q

Si

Exemple dutilisation : la multiplication-accumulation permet de calculer un produit de convolution. Cest lopration de base du filtrage numrique.

Le chronogramme de fonctionnement est le suivant (on prsente A et B sur le front descendant de lhorloge, registre mis 0 au dmarrage) :
clk

reset

A 0 B 0 P 0 Si U Somme U 0 9 25 46 70 95 0 9 18 25 41 46 67 70 94 95 120 9 16 21 24 25 9 8 7 6 5 1 2 3 4 5

Le registre doit tre initialis 0 au dbut du calcul de la somme des produits. Il faut

utiliser un reset synchrone car ce reset est fonctionnel. 169

4.8.7 Les monostables

Un monostable est un circuit logique squentiel qui dlivre, sur le front actif dun signal de commande, une impulsion de dure variable ajuste par un rseau RC. La dure de limpulsion est approximativement gale 0,7.Rext.Cext. Son ordre de grandeur est compris entre une dizaine de nano-secondes et plusieurs secondes. Nous allons examiner deux types courants de monostables :
SN74LS221 : double monostable non rarmable avec entre trigger de Schmitt. Si un front

actif se produit avant que limpulsion de sortie ne revienne au repos, il nest pas pris en compte. Sa table de vrit est la suivante :

entres clear 0 X X 1 1

sorties B X X 0

A X 1 X 0

Q 0 0 0

Q 1 1 1

1 1

SN74LS123 : double monostable rarmable. Si un front actif se produit avant que

limpulsion de sortie ne revienne au repos, sa dure est tendue de la valeur initiale. Sa table de vrit est identique la prcdente.

Entre active Sortie monostable non rarmable


Largeur impulsion

Sortie monostable rarmable


Largeur impulsion

Les monostables ne sont plus utiliss aujourdhui en conception des circuits logiques. Mais le principe est toujours intressant, notamment sous sa forme squentielle synchrone (sans rseau RC bien sur).

170

4.8.8 Circuit de dtection de front

Il arrive trs souvent dans un design quil soit ncessaire de dtecter si un signal a chang dtat : cest la dtection de front, montant ou descendant. En logique synchrone, nous allons utiliser pour cela une horloge qui doit tre plus rapide que le rythme du changement dtat sur le signal dtecter (par exemple, au moins 10 fois plus rapide). Prenons lexemple dun signal x qui est une entre asynchrone par rapport lhorloge du design. Les chronogrammes suivants montrent le principe de la dtection du front :
clk

reset

xr1

xr2

xr3

cef = xr2.xr3

cer = xr2.xr3

171

Le montage correspondant est le suivant :

cer
Double resynchronisation ncessaire si x asynchrone

cef xr2 xr3

xr1

clk
cer est un signal de validation qui vaut 1 pendant une priode de clk sil y a eu un front

montant sur x. cef vaut 1 sur un front descendant de x. Si x est synchrone, on peut supprimer les deux premires bascules du montage qui servent seulement rduire la mtastabilit si x est asynchrone (mthode de la double resynchronisation).
4.9 Description en VHDL

4.9.1 Latch transparent et bascule D

Nous avons vu la fin de lexemple du multiplexeur (2.4.3) le phnomne de la mmorisation implicite qui gnrait un latch quand toutes les branches dune assignation conditionnelle ntaient pas dfinies. Cela pouvait sembler tre un inconvnient majeur. En fait, cette mmorisation implicite permet la simplification de la description des circuits squentiels. Lexemple suivant vous montre une bascule D la plus simple possible :

1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. entity basc is 4. port(D : in std_logic; 5. clk : in std_logic; Q : out std_logic); 6. 7. end basc;

172

8. architecture comporte of basc is 9. begin 10. process(clk) begin 11. if (clk'event and clk ='1') then 12. Q <= D; 13. end if; 14. end process; 15. end comporte ;

Le process est sensible au seul signal actif du design, lhorloge clk. A la ligne 11, dans le if, on trouve lattribut event. Accol un signal, il retourne un boolen qui sera vrai si un vnement (cest dire un changement dtat) sest produit sur ce signal. Par exemple, la forme :
if (CLK'event and CLK='1') then

sera utilise pour dtecter un front montant dhorloge (sil y a eu changement dtat sur CLK et si CLK vaut 1). La forme :
if (CLK'event and CLK='0') then

sera utilise pour dtecter un front descendant dhorloge (sil y a eu changement dtat sur CLK et si CLK vaut 0). Le package std_logic_1164 dfinit deux fonctions quivalentes
rising_edge(CLK) et falling_edge(CLK) qui pendant longtemps nont pas t

reconnus par les synthtiseurs (notamment celui de Synopsys). Cest pourquoi beaucoup de designers utilisent encore la forme (CLK'event and CLK='1'). Noubliez surtout pas
le CLK'event mme si dans cet exemple on pourrait croire quil ne sert rien. Cest vrai en

simulation, mais le synthtiseur en a besoin pour infrer correctement une bascule D. Voyons le fonctionnement de la bascule D, lignes 10 14. Le process est activ (ligne 10) par lhorloge clk. Si le front montant de lhorloge arrive (ligne 11) alors Q prend la valeur de D (ligne 12). Sinon (le if then else est incomplet), Q garde son tat prcdent. Il sagit l de la description dune bascule D. On voit ici tout lintrt de la mmorisation implicite. Il suffit donc de mettre une assignation entre deux signaux dans la branche
sensible lhorloge if (clock 'event and clock ='1') then pour gnrer

(infrer) une bascule D. La description est quivalente au schma :

173

La bascule D ainsi gnre est dpourvue de reset. Ltat de Q est donc inconnu au dpart comme le montre la simulation suivante :

Etat Unknown La description dun latch transparent est aussi simple. Il suffit de retirer le clkevent dans le if.
10. 11. 12. 13. 14. process(clk, D) begin if (clk ='1') then Q <= D; end if; end process; -- D active le process car quand -- clk = 1, D est copie dans Q -- en permanence

Quand clk vaut 1, on copie D sur Q en permanence, et quand clk vaut 0, on garde le dernier tat stock sur Q. La description est quivalente au schma :

Revenons notre bascule D. On peut lui ajouter un reset asynchrone de la manire suivante :
process(clk, clear) begin -- clk et clear active le process, clear prioritaire if (clear ='1') then -- si clear vaut 1 Q <= '0'; -- alors Q prend la valeur 0 elsif (clk'event and clk ='1') then -- sinon, si front montant sur clk Q <= D; -- alors Q prend la valeur de D end if; -- sinon Q garde sa valeur prcdente end process;

174

Le clear est bien asynchrone puisque le if (clear ='1') est en dehors de la branche sensible lhorloge elsif (clock 'event and clock ='1') . clear est dans la liste de sensibilit du process puisque cest un signal actif. Le elsif est ici absoluement
obligatoire. On ne doit tester le front dhorloge que si clear est 0 car le clear est

prioritaire sur lhorloge. Cette description est quivalente au schma :

Si le if (clear ='1') tait dans la branche sensible lhorloge elsif (clock


'event and clock ='1') alors le clear serait synchrone comme dans lexemple

suivant. Clear a disparu de la liste de sensibilit du process car ce nest plus un signal actif. Seule lhorloge clk est active.
process(clk) begin -- clear a disparu car il est synchrone. if (clk'event and clk ='1') then --si front montant sur clk if (clear ='1') then -- si clear vaut 1 Q <= '0'; -- alors Q prend la valeur 0 else Q <= D; -- sinon Q prend la valeur de D end if; end if; -- sinon Q garde sa valeur prcdente end process;

On peut de plus ajouter un signal de validation ce de la manire suivante :


process(clk, clear) begin -- clk et clear active le process if (clear ='1') then -- si clear vaut 1 Q <= '0'; -- alors Q prend la valeur 0 elsif (clk'event and clk ='1') then -- sinon, si front montant sur clk if (ce ='1') then -- si ce vaut 1 Q <= D; -- alors Q prend la valeur de D end if; -- sinon Q garde sa valeur prcdente end if; -- sinon Q garde sa valeur prcdente end process;

On pourrait en toute logique ajouter la condition sur le ce directement dans la condition en crivant elsif (clock'event and clock='1' and ce='1'). Ce type de description a une nette tendance a perturber le synthtiseur. Il vaut mieux dcomposer les conditions. Cette description est quivalente au schma : 175

4.9.2 Registre

La description dun registre N bits en VHDL diffre fort peu de la description dune bascule D. Il suffit de dclarer D et Q comme std_logic_vector(N-1 downto 0). Lexemple suivant dcrit un registre 8 bits :

library IEEE; use IEEE.std_logic_1164.all; entity reg port(D : clear : ce : clk : Q : end reg; is in std_logic_vector(7 downto 0); in std_logic; in std_logic; in std_logic; out std_logic_vector(7 downto 0));

architecture comporte of reg is begin process(clk, clear) begin if (clear ='1') then Q <= (others => '0'); -- tous les bits de Q 0 elsif (clk 'event and clk ='1') then if (ce ='1') then Q <= D; end if; end if; end process; end comporte ;

On voit encore une fois lintrt de la mmorisation implicite. Il suffit de mettre une assignation entre deux signaux dans la branche if (clock 'event and clock
='1') then pour gnrer (infrer) un registre. Cest la taille des signaux qui dtermine la

taille du registre. Vous voyez ici tout lintrt dutiliser un langage comme VHDL plutt quune saisie de schma. La description est quivalente au schma : 176

4.9.3 Registre dcalage

Le registre dcalage est peine plus compliqu dcrire que le registre simple. Il ncessite lutilisation dune boucle for :

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.

library IEEE; use IEEE.std_logic_1164.all; entity shift is port( CLK : in std_logic ; CLEAR : in std_logic; CE : in std_logic; Din : in std_logic; Q : out std_logic_vector(7 downto 0)); end shift; architecture RTL of shift is signal Qint : std_logic_vector(Q'range); begin process(CLK, CLEAR) begin if (CLEAR='1') then Qint <= (others => '0'); elsif (CLK'event and CLK='1') then if (ce = '1') then for i in 1 to 7 loop Qint(8-i) <= Qint(7-i); end loop; Qint (0) <= Din; end if; end if; end process; Q <= Qint; end;

Les points suivants sont importants :


Ligne 11 : lattribut range. Il fait partie des nombreux attributs de VHDL. Si le signal A est

dfini par un std_logic_vector(X downto Y), alors A'range est quivalent X


downto Y et peut tre utilis la place. Dans notre exemple :

177

signal Qint : std_logic_vector(Q'range);

Qint a la mme largeur que Q (de 7 0). Lattribut range simplifie lcriture des modles gnriques.
Ligne 25. Il est impossible en VHDL dutiliser la valeur dun signal dans larchitecture

dun composant sil a t dclar en sortie pure dans lentit. Lassignation suivante ne peut pas tre effectue sur le signal Q.

Qint(8-i) <= Qint(7-i);

On effectue donc lassignation sur un signal dclar localement Qint, puis on assigne ce signal temporaire la sortie Q en dehors du process (pour ne pas gnrer une bascule de trop).

Q <= Qint;

On aurait pu contourner ce problme en dclarant Q en mode buffer, ce qui aurait autoris son utilisation dans larchitecture. On nutilise jamais ce mode, car il y a trop de restrictions son utilisation. Le mode buffer nest plus utilis en VHDL, la dclaration dun signal temporaire comme Qint donne une reprsentation strictement quivalente.
Le dcalage du registre est ralis aux lignes 18 21. Si CE vaut 1, alors on copie Qint(6)

dans Qint(7), puis Qint(5) dans Qint(6), puis Qint(4) dans Qint(5), , puis Qint(0) dans Qint(1). Il suffit ensuite de copier din dans Qint(0) pour terminer le dcalage. Vous noterez lutilisation de la boucle for qui est spatiale en VHDL alors quelle est temporelle dans un langage de programmation comme le C. Le chronogramme suivant montre lvolution des signaux :

178

4.9.4 Compteur
1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. use IEEE.std_logic_unsigned.all; 4. entity compteur is 5. port( CLK : in std_logic ; 6. CE : in std_logic ; 7. CLEAR : in std_logic; 8. CEO : out std_logic; 9. DOUT : out std_logic_vector(3 downto 0)); 10.end compteur; 11.architecture a1 of compteur is 12. signal INT_DOUT : std_logic_vector(DOUT'range) ; 13.begin 14. process(CLK, CLEAR) begin 15. if (CLEAR='1') then 16. INT_DOUT <= (others => '0'); 17. elsif (CLK'event and CLK='1') then 18. if (CE='1') then 19. INT_DOUT <= (INT_DOUT + 1); 20. end if; 21. end if; 22. end process; 23. CEO <= INT_DOUT(0) and INT_DOUT(1) and INT_DOUT(2) and INT_DOUT(3) and CE; 24. dout <= int_dout; 25.end;

Les points suivants doivent tre nots :


Ligne 3. Le package std_logic_1164 dfinit le type std_logic, mais pas les oprateurs

arithmtiques qui vont avec. Le package propritaire Synopsys std_logic_unsigned dfinit ces oprateurs en considrant que le type std_logic est non sign. Cette dclaration est obligatoire par exemple pour effectuer lopration suivante avec INT_DOUT dclar comme un signal std_logic_vector :

INT_DOUT <= (INT_DOUT + 1);

Ligne 23. Le signal CEO passe 1 quand ltat final de la squence de comptage est atteint

(ici, la valeur 15) et quand le signal de validation dentre CE vaut 1. Ceci est traduit par lassignation :
CEO <= INT_DOUT(0) and INT_DOUT(1) and INT_DOUT(2) and INT_DOUT(3) and CE;

Pourquoi cette assignation nest-elle pas dans le processus synchrone ? parce que CEO passerait 1 sur le front dhorloge qui suit le dclenchement de la condition (cest dire quand la sortie du compteur est gale 0. Noubliez pas la bascule D qui est 179

automatiquement gnre ! Il faudrait donc dtecter la valeur (tat final 1) pour que CEO passe 1 sur ltat final, ce qui ne serait pas trs clair pour la comprhension du design. La solution consiste donc raliser une dtection purement combinatoire de ltat final, donc en dehors du process synchrone. Le chronogramme suivant montre le fonctionnement du compteur. On voit bien que CEO passe 1 pendant ltat 15 :

Pour raliser un compteur BCD (qui va de 0 9), il suffit de remplacer la ligne 19 :


INT_DOUT <= (INT_DOUT + 1);

Par les lignes suivantes :


if (INT_DOUT=9) then INT_DOUT <= (others => '0'); else INT_DOUT <= (INT_DOUT + 1); end if;

Le CEO doit tre modifi de la manire suivante :


CEO <= INT_DOUT(0) and not INT_DOUT(1) and not INT_DOUT(2) and INT_DOUT(3) and CE;

Le chronogramme suivant montre le nouveau fonctionnement du compteur :

La logique utilise pour raliser un compteur est gnralement base sur un additionneur associ un registre, notamment dans les FPGA. Cest la mthode la plus simple pour raliser le comptage. Elle utilise un minimum de logique et de ressource de routage et donne la frquence maximum la plus leve. Voici lexemple dun compteur binaire 8 bits.

180

Q 8

Equation ralise : Qn+1 = Qn + 1

clk

Pour raliser un dcompteur, il suffit de remplacer le 1 par un -1 dans le schma prcdent et de remplacer la ligne 19 du compteur par :

INT_DOUT <= (INT_DOUT - 1);

4.9.5 Accumulateur

Voici un exemple daccumulateur de somme non sign :


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. library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; entity accu_som is port( CLK : in std_logic ; CE : in std_logic ; CLEAR : in std_logic; X : in std_logic_vector(7 downto 0); Somme : out std_logic_vector(13 downto 0)); end accu_som; architecture a1 of accu_som is signal Si : std_logic_vector(Somme'range) ; signal Somme_int : std_logic_vector(Somme'range) ; begin Si <= "000000"&X + Somme_int; Somme <= Somme_int; process(CLK) begin if (CLK'event and CLK='1') then if (CLEAR='1') then Somme_int <= (others => '0'); elsif (CE='1') then Somme_int <= Si; end if; end if; end process; end;

181

La description du design ne pose pas de problmes particuliers. A la ligne 15, on concatne 6 zros gauche de X pour convertir le signal 8 bits non sign en un signal non sign de 14 bits que lon additionne avec Somme. Et la ligne 22, on copie le rsultat Si dans le registre 14 bits. Comme pour le compteur, on travaille avec un signal temporaire Somme_int que lon copie dans Somme la ligne 16. Dans cet exemple, le Clear est fonctionnel et doit tre
obligatoirement synchrone. Le fonctionnement est conforme la thorie vue au 4.8.5.

4.9.6 MAC

Il suffit de modifier lgrement laccumulateur de somme prcdent pour raliser un MAC (sign cette fois) :
1. library IEEE; 2. use IEEE.std_logic_1164.all; 3. use IEEE.std_logic_signed.all; 4. entity mac is 5. port( CLK : 6. CE : 7. CLEAR : 8. A : 9. B : 10. Q : 11. end mac; 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. in std_logic; in std_logic; in std_logic; in std_logic_vector(15 downto 0); in std_logic_vector(15 downto 0); out std_logic_vector(35 downto 0));

architecture a1 of mac is signal P : std_logic_vector(31 downto 0); signal Si, Q_int : std_logic_vector(Q'range); begin P <= A*B; Si <= P(31)&P(31)&P(31)&P(31)&P + Q_int; Q <= Q_int; process(CLK) begin if (CLK'event and CLK='1') then if (CLEAR='1') then Q_int <= (others => '0'); elsif (CE='1') then Q_int <= Si; end if; end if; end process; end;

182

La description du design est assez directe. A la ligne 16, on ralise le produit sign P = A*B. A la ligne 17, on convertit P de 32 bits signs en 36 bits signs par extension de signe puis on ladditionne avec Q. Et la ligne 24, on copie le rsultat Si dans le registre 36 bits. Dans cet exemple, le Clear est fonctionnel et doit tre obligatoirement synchrone. Le fonctionnement est conforme la thorie vue au 4.8.6.

4.9.7 Circuit de dtection de front

La description en VHDL est vidente et nappelle pas de commentaires particuliers. Voici un exemple de circuit de dtection de front montant :
library IEEE; use IEEE.std_logic_1164.all; entity front port(clk reset x cer end front; is : in std_logic ; : in std_logic; : in std_logic; : out std_logic);

architecture a1 of front is signal xr1 : std_logic; signal xr2 : std_logic; signal xr3 : std_logic; begin cer <= xr2 and not xr3; process(clk, reset) begin if (reset = '1') then xr1 <= '0'; xr2 <= '0'; xr3 <= '0'; elsif (clk'event and clk='1') then xr1 <= x; xr2 <= xr1; xr3 <= xr2; end if; end process; end;

Le chronogramme suivant montre son fonctionnement : 183

4.10 Exercices

Exercice 4.1 Un interrupteur manuel qui commute dune ancienne position vers une nouvelle ntablit pas un contact franc avec la nouvelle position, mais il rebondit en lair un certain nombre de fois avant de se stabiliser dessus. Nous allons voir dans cet exercice un montage dit anti-rebonds. 1. Soit le schma suivant : VCC

1 2 R S

Donner le chronogramme de la sortie S quand l'interrupteur passe de la position 2 la position 1. 2. Mme question quand il passe de 1 2. 3. On utilise maintenant le montage suivant :

VCC

R 1 2 R

Expliquer son fonctionnement. Quel est l'avantage par rapport au montage prcdent ? Exercice 4.2 184

Soit le schma suivant :


A

R Q H S

D B

1. Indiquer ltat des points A, B, R, S, Q et Q quand H est ltat haut, quand H passe de ltat haut ltat bas, quand H est ltat bas et quand H passe de ltat bas ltat haut. 2. Quel type de bascule a-t-on ralis ? Exercice 4.3 Soit le montage suivant compos dune bascule D (SN74LS74) et de portes NAND (SN74LS00).
1 SD T D Q

CP CD 1

1. Dessiner lallure du chronogramme en sortie de la bascule. 2. Rappeler la dfinition et donner la valeur des temps de setup, de hold et de propagation des circuits composant le montage. 3. Quelle est la frquence maximale (dans le pire des cas) de fonctionnement de ce montage ? Exercice 4.4 185

Que se passe-t-il si les temps de setup et de hold ne sont pas respects quand un signal asynchrone est prsent lentre d'une bascule ? Sa sortie est alors dans un tat indtermin qui peut tre un tat intermdiaire compris entre 0 et 1, un tat mtastable. Ce phnomne est connu sous le nom de mtastabilit. Le chronogramme suivant lillustre. D

t D H Q 1 0 t Q H

Ce problme se pose systmatiquement ds que lentre dun systme synchrone est asynchrone. Il y a alors forcment une chance pour que lentre asynchrone ne respecte pas les temps de setup et de hold dune des bascules. La consquence pratique de ce phnomne nest pas lapparition dun tat intermdiaire entre le 0 et le 1 logique. Au bout dun certain temps, la bascule choisit un niveau et passe 0 ou 1. Cest le temps au bout duquel elle basculera (si elle change dtat) qui est indtermin. Ce qui est sr, cest quil est largement suprieur au temps de propagation de la bascule utilise dans des conditions normales de fonctionnement. Soit le montage suivant :

entre asynchrone

D H

QA

D H

QB

D H

QC

D H

QD

EN H

compteur 16 bits

horloge

afficheur

1. Expliquer, laide des chronogrammes des diffrentes sorties, comment ce montage permet de quantifier le phnomne de mtastabilit.

186

2. Le temps moyen entre deux erreurs dacquisition (MTBF) ne peut tre dfini que de e K 2 .t avec F2 = frquence dhorloge, F1 = frquence manire statistique. MTBF = F1 .F2 .K 1 moyenne du signal asynchrone, K1 = constante = 0.1 ns, K2 = constante dpendant de la technologie de la bascule et t = temps de setup effectif. Cette formule nest valable que si les deux frquences sont indpendantes et sans corrlation. On pose F1 = 1 MHz, F2 = 10 MHz et K2 = 19.4 [1/ns]. Calculer le MTBF pour t = 0, 500 ps, 1 ns, 1.5 ns, 2 ns.

Exercice 4.5 Soit le montage suivant :

J0 S Q0 H K0 R Q0
1

J1 S Q1 H K1 R Q1

J2 S Q2 H K2 R Q2

J3 S Q3 H K3 R Q3

H RAZ

La RAZ est asynchrone et active au niveau bas. 1. Dessiner le chronogramme des diffrentes sorties du montage en commenant par une RAZ. 2. Quelle est sa fonction ?

Exercice 4.6 1. On considre le montage suivant. Quelle fonction a-t-on ralise ?

SR

D0 H

Q0

D1 H

Q1

D2 H

Q2

D3 H

Q3

187

2. On considre le montage suivant. Quelle fonction a-t-on ralise ?


SL D0 H H Q0 D1 H Q1 D2 H Q2 D3 H Q3

3. On combine les deux fonctions prcdentes selon le schma suivant. Effectuer la synthse dun oprateur M laide de portes standards. SL SR M
S0

D0 H

Q0

M
S0

D1 H

Q1

M
S0

D2 H

Q2

M
S0

D3 H

Q3

4. On dsire ajouter une fonction de chargement du mot form par A, B, C, D en Q0, Q1, Q2,
Q3 selon le schma suivant. Effectuer la synthse dun oprateur M laide de portes standards.
SL SR M
S0S1

D0 H

Q0

M
S0S1

D1 H

Q1

M
S0S1

D2 H

Q2

M
S0S1

D3 H

Q3

H A B C D

5. On dsire ajouter au schma prcdent une fonction de validation EN. Proposer un schma du nouveau montage ainsi que de la fonction M.

188

Exercice 4.7 On tudie dans cet exercice la ralisation dun compteur binaire ainsi que la meilleure manire d'associer des compteurs binaires en cascade. On nutilisera que des portes combinatoires deux entres et des bascules D. On prendra comme rfrence les circuits SN74LS00 et SN74LS74. 1. Comment ralise-t-on une bascule T partir dune bascule D ? Quelle est sa frquence maximale de fonctionnement ? 2. Comment ralise-t-on un compteur binaire 2 bits partir de bascules T ? Quelle est sa frquence maximale de fonctionnement ? 3. Mme questions pour un compteur 3 bits, 4 bits, N bits. Conclusion. 4. On dsire pouvoir associer en cascade ce compteur (4 bits). Quels types de signaux faut-il lui ajouter pour rendre cette association possible ? Quelle est la frquence maximale de fonctionnement des circuits mis en cascade pour former un compteur 16 bits, 32 bits ? 5. On souhaite amliorer la frquence de fonctionnement maximale de ce montage. On va pour cela scinder le signal dentre de validation en deux signaux, EN P (enable parallel) et EN T (enable trickle). Lassociation a maintenant lieu selon le schma suivant :

1 EN P EN T CK
QA QB QC QD

EN P RCO 1 EN T CK
QA QB QC QD

EN P RCO EN T CK
QA QB QC QD

EN P RCO EN T CK
QA QB QC QD

RCO

Proposer un schma permettant de tirer parti des spcificits de la validation et de raliser ce type dassociation. Quelle est la frquence maximale de fonctionnement des circuits mis en cascade pour former un compteur 16 bits, 32 bits ? Exercice 4.8 Soit le schma interne du compteur SN74LS163.

189

Ce circuit est conu pour pouvoir tre mont en cascade de la manire suivante :

1. Comment ralise-t-on une bascule T partir dune bascule D ? 2. On pose load = 1, clear = 1 et enable P = enable T = 1. Supprimer du schma de la bascule les portes inutiles et analyser le fonctionnement du montage. Pourquoi ne ralise-t-on pas directement des compteurs de grande taille avec cette mthode ? Quelle est alors la solution ? 3. On passe clear 0. Analyser le fonctionnement du montage. La RAZ est-elle synchrone ou asynchrone ? 190

4. On passe clear 1 et load 0. Analyser le fonctionnement du montage. Le chargement estil synchrone ou asynchrone ? 5. On passe load 1 et enable P et T 0. Analyser le fonctionnement du montage. 6. Supposons que lon nait quun seul signal de validation. Quelle serait la limitation en frquence de lassociation en cascade (sur 16 bits et 32 bits) ? 7. Quel est alors lavantage davoir deux signaux de validation ? Quelle est la limitation en frquence de lassociation en cascade (sur 16 bits et 32 bits) ?

191

192