modules vhdl

Modules numériquesdécrits en VHDL

ENIT - Génie ÉlectriqueBourguiba Riadh

[email protected]

Bourguiba Riadh - ENIT - Génie Electrique

2Modules numériquesdécrits en VHDL

1. Logique combinatoire

2. Logique séquentielle



A. Additionneur

B. Opposé


4A. Additionneur

i. Architecture structurelle

ii. Architecture flot de données

iii. Simulation


5i. Architecture structurelle

L'additionneur binaire peut se construire à partir d'éléments plus simples.

On peut ainsi construire une porte non-et, puis un demi-additionneur, puis un additionneur 1 bit et enfin un additionneur N bits.

La dépendance des fichier sera le suivante :

addN

add1

demi_add

nand2

Top-level



La porte nand2 s’écrit directement en flot de données, avec l’opérateur nand du paquetage std_logic_1164 de la librairie IEEE.



Pour le demi-additionneur il suffit d’assembler plusieurs portes Nand2 conformément au schéma suivant :

Ce dernier résulte des tables de vérité de c et de s.



Le code VHDL du demi-additionneur s’écrit :



Remarquez que la porte nand2 n’est pas déclarée dans la zone de déclaration de l’architecture.

En effet, la déclaration est faite dans un fichier de paquetage pack.

Le demi-additionneur fait appel à ce paquetage grâce aux lignes 4 et 5.

La porte nand2 est utilisable dans tous les fichiers VHDL qui font appel au paquetage pack.

Si l’on modifie l’entité de nand2, il suffira de mettre à jour le paquetage pack, pour qu’automatiquement toutes les instances de nand2 bénéficient des modifications de son entité.

Centraliser les déclarations de composants présente un grand intérêt lorsque l’on développe des systèmes complexes.



Le code VHDL du paquetage pack s’écrit :

Dorénavant, nous ajouterons à ce paquetage les déclarations de tous les composants au fur et à mesure de nos développements, sans le montrer.

Aussi on se contentera de faire appel à pack en supposant que les déclarations y sont déjà contenues.



Maintenant, il faut assembler deux demi-additionneurs pour créer un additionneur 1 bit :

On effectue d’abord la somme des bits a et b, à laquelle on ajoute ensuite c

in

demi_add(U1)

a

b

c

s

a

bdemi_add

(U2)

a

b

c

scin

cout

s

s1

s2

s3U3



Le code VHDL de l’additionneur 1 bit s’écrit :



Les modules précédents n'avaient qu'une seule entité et une seule architecture.

Leur description commençait par les appels aux paquetages, continuait avec l'entité et se terminait par l'architecture.

Dans le cas où un module possède plusieurs architectures, il est d’usage de placer l’entité en début du fichier source VHDL, suivie de ses différentes architectures.

Chaque unité de conception doit alors être précédée de ses propres appels aux paquetages externes dont elle a besoin.

Nous allons suivre cette organisation pour notre top-level (addN).



L’additionneur N bits est un composant générique, capable de s’adapter à un nombre de bits paramétrable .

Son entité présentera donc un paramètre N de type entier.

On fixera la valeur de N à chaque instanciation (utilisation) de addN.



Une architecture possible pour réaliser addN repose sur l’instanciation répétitive d’add1.

Celle-ci utilise le paramètre N dans une boucle de génération itérative :

… : for ... in … generate

…

end generate;

Notez qu'en VHDL le compteur de boucle est obligatoirement un entier. Il n’a donc pas besoin d’être déclaré.

Reste maintenant à décomposer notre additionneur N bits en N additionneurs 1 bit.



La somme sur N bits et l’addition 1 bit s’écrivent :

Il faut normaliser les largeurs de données pour dessiner une structure régulière que l’on pourra décrire simplement.

cn … c1an-1 … a0

+ bn-1 … b0

sn sn-1 … s0

cout cin a

+ b

s



Pour cela, on ajoute les bits en rouge :

c0 est fixé à 0, car il n’y a pas de retenue provenant de rangs inférieurs.

Si l’additionneur travaille uniquement sur des entiers positifs codés en binaire simple, alors a

n et b

n sont fixés à 0.

Si l’additionneur travaille sur des nombres signés en complément à 2, alors an

et bn sont obtenus par extension de signe (a

n-1 et b

n-1).

cn+1 cn … c1 c0an an-1 … a0

+ bn bn-1 … b0

sn sn-1 … s0



Le code VHDL de l’architecture structurelle de addN (partie 1/2) s'écrit :



Le code VHDL de l’architecture structurelle de addN (partie 2/2) s'écrit :


20A. Additionneur



iii. Simulation


21ii. Architecture flot de données

Une autre architecture possible pour addN repose sur l’utilisation de l’opérateur ‘+’ définit dans le paquetage std_logic_unsigned ou std_logic_signed de la librairie IEEE :


22A. Additionneur



iii.Simulation


23iii. Simulation

La simulation de notre composant nécessite la création de banc de test ou testbench.

Un testbench est un composant virtuel destiné à créer un environnement de simulation pour un composant réel.

A ce titre, il ne possède aucun port, mais il peut avoir des paramètres génériques.

Il est conçu en vue de la simulation uniquement, pas de la synthèse.

Il instancie le composant à tester et stimule ses entrées.

Par convention, son nom est celui du module testé (ex : module), précédé du préfixe tb_ (ex : tb_module).


24iii. Simulation

Pour notre testbench, nous utiliserons un paramètre générique N.

La valeur de N sera fixée par défaut, directement dans l’entité.

Nous appellerons également le paquetage std_logic_arith , qui contient la fonction conv_std_logic_vector qui permet de convertir un entier en un vecteur logique et dont on se servira dans l’architecture.


25iii. Simulation

Étant donné le grand nombre de valeurs binaires possibles, nous utilisons deux boucles imbriquées pour générer a et b (lignes 32 à 38).

Par ailleurs, le choix de l’architecture simulée se fait à la ligne 16,

=> Un testbench sert à simuler toutes les architectures d’une même entité.


26iii. Simulation


27iii. Simulation

On obtient pour les chronogrammes suivant :



A. Additionneur

B. Opposé


29B. Opposé

i. Introduction

ii. Architecture structurelle

iii. Architecture flot de données

iv. Simulation


30i. Introduction

La recherche de l’opposé d’un nombre signé noté en complément à 2 est une opération très courante dans les systèmes logiques.

Algorithme 1 : Recopier tous les bits de la droite vers la gauche jusqu’au premier bit à 1 inclus, puis inverser les bits suivants.

Algorithme 2 : Inverser tous les bits, puis ajouter 1.


31B. Opposé

i. Introduction



iv. Simulation


32ii. Architecture structurelle

Cette structure exploite une propriété intéressante de la porte XOR : l’inversion commandée.

Commande=0 => e

Commande=1 => not e

Sur le schéma, on distingue clairement 3 blocs identiques0

a0 b0

a1 b1

a2 b2Commande e Xor

0 0 0

0 1 1

1 0 1

1 1 0



Notre description utilisera donc ce bloc élémentaire 1 bit (opp1), pour générer un bloc de taille variable (oppN).

opp1

oppN Top Levela d

b

c



Description VHDL de opp1 :



Une simple boucle de génération permet ensuite d’écrire oppN.


36B. Opposé

i. Introduction


iii.Architecture flot de données

iv. Simulation


37iii. Architecture flot de données

Pour cette description, on aura besoin de l’opérateur not et de l’opérateur ‘+’ appliqués à un vecteur de bits signé.

Ceux-ci sont définis dans le paquetage std_logic_signed de la librairie IEEE.

L’architecture obtenue s’écrit :


38B. Opposé

i. Introduction



iv.Simulation


39iv. Simulation

Entité


40iv. Simulation

Architecture


41iv. Simulation

Chronogrammes :


42Modules numériquesdécrits en VHDL





A. Bascule D

B. Registre

C. Registre à décalages

D. Compteur/décompteur


44A. Bascule D

i. Introduction

ii. Entité

iii. Architecture séquentielle avec signal

iv. Architecture séquentielle avec variable

v. Simulation


45i. Introduction

La bascule D est une circuit séquentiel synchronisé avec une horloge, clk, qui mémorise une simple information binaire, à un instant privilégié du cycle, si certaines conditions sont réunies.

L'instant privilégié de l'horloge est indiqué par un front qui peut être montant ou descendant, selon le type de bascule.

Un signal permet de forcer la valeur de sortie de la bascule au démarrage :

reset : valeur de sortie forcée à zéro.

set : valeur de sortie forcée à un.

La prise en compte de ce signal peut dépendre de l'horloge (reset ou set synchrone), ou bien ne pas en dépendre (reset ou set asynchrone).

Un signal de validation, enable, permet de valider ou d'ignorer les fronts actifs de l'horloge.

Enfin, reset, set et enable sont facultatifs et peuvent être actif à l'état bas ou à l'état haut.


46i. Introduction

On considère la bascule D suivante :

La bascule D est remise à zéro de façon asynchrone lorsque r est vrai.

La donnée D est recopiée dans Q, sur front montant de clk, à condition que e soit vrai.

e

D Q

clkr


47A. Bascule D

i. Introduction

ii. Entité



v. Simulation


48ii. Entité

L'entité s'écrit conformément au symbole :

e

D Q

clkr


49A. Bascule D

i. Introduction

ii. Entité

iii.Architecture séquentielle avec signal


v. Simulation


50iii. Architecture séquentielle avec signal



Supposons dans un premier temps que q et q_tmp sont confondus.

La liste de sensibilité

Elle est extrêmement importante. Elle comporte une liste des signaux susceptibles de modifier le résultat du process (ici q_tmp). Ces dernier doivent donc provoquer l'activation du process.

Elle contient les signaux asynchrones (qui ne dépendent pas de l'horloge), ainsi que l'horloge elle même.

En revanche, les signaux synchrones n'ont pas besoin d'y être placés, car leur valeur n'est prise en compte que sur front actif de l'horloge et que celle-ci est déjà dans le liste.

Si on ajoute les signaux synchrones à la liste, ils ralentiront inutilement la simulation.



L'horloge

C'est un signal de contrôle particulier : il doit se propager sur un réseau de routage optimisé pour garantir que les fronts d’horloge actifs se produiront au même instant à travers tout le circuit.

=> il faut donc le distinguer des autres signaux.

Pour cela, on le teste séparément, après avoir testé les signaux asynchrones (r) et avant de tester les signaux synchrones (e). Ainsi les outils de synthèse seront à même de l’identifier sans aucune ambiguïté.



Affectations conditionnelles

q_tmp étant un signal, il faut préciser sa valeur de sortie dans TOUTES les circonstances.

=> Sinon, l’outil de synthèse risque de choisir les valeurs qui l’arrangent pour les cas de non spécifiés…

Toute affectation d'une valeur à un signal dans un process ne deviendra effective qu'à la sortie du process (franchissement de end process).

Signal q_tmp

On travaille avec le signal q_tmp, car ce signal interne peut être lu et écrit, contrairement au port de sortie q, qui ne peut être que écrit.

q_tmp est connecté au port de sortie q, n'importe où à l'extérieur du process.


54A. Bascule D

i. Introduction

ii. Entité


iv.Architecture séquentielle avec variable

v. Simulation


55iv. Architecture séquentielle avec variable


56iv. Architecture séquentielle avec variable

Cette fois ci, on définit q_tmp comme une variable et non plus comme un signal.

Une variable est locale au process et conserve sa valeur entre deux activations successives (come une variable static en C).

Par conséquent, il est possible cette fois-ci de supprimer les lignes 58 et 60, puisqu'il n'y a pas de modification de la valeur de la variable et que celle-ci est conservée automatiquement. On préfère toutefois rester explicite par soucis de maintenabilité du code.

L'opérateur d'affectation d'une variable est := et l'affectation est immédiate.

Après élaboration du résultat, la variable q_tmp doit être affectée au port de sortie q. En général, on effectue cela à la fin du process, pour que q reflète les changements.


57A. Bascule D

i. Introduction

ii. Entité



v. Simulation


58v. Simulation

Il faut générer trois signaux de contrôle :

le reset (r)

l’horloge (clk)

le enable (e)

Il existe plusieurs façons de les créer. En voici deux différentes, mais toutes aussi efficaces.


59v. Simulation

Pour le reset il faut générer une impulsion au démarrage du système.

Solution 1

1. Lui affecter une première valeur dans un processus et attendre un certain délai,

2. puis changer cette valeur et suspendre définitivement le processus.

Solution 2

Lui affecter une valeur d’initialisation, puis lui affecter une valeur définitive après un délai, à partir d’une seule instruction.


60v. Simulation

Pour l’horloge, il faut générer un signal périodique.

Solution 1

1. Déclarer le signal d’horloge normalement.

2. Lui affecter une première valeur dans un processus et attendre un certain délai,

3. puis changer cette valeur et attendre le même délai avant de recommencer.

Solution 2

1. Déclarer le signal et lui affecter une valeur d’initialisation.

2. Inverser cette valeur au bout d’un délai et recommencer, le tout avec une seule instruction.


61v. Simulation

L'entité du testbench est vide :

Elle n'a pas besoin de paquetages, puisqu'elle n'a ni ports d'entrée/sortie, ni paramètres.

Nous allons maintenant envisager deux architectures pour le testbench de la bascule D, afin d'illustrer les différentes syntaxe de génération du reset et de clk.


62v. Simulation

1ère architecture


63v. Simulation

2ème architecture


64v. Simulation

Chronogrammes



A. Bascule D

B. Registre




66B. Registre

i. Introduction

ii. Entité



v. Simulation


67i. Introduction

Les registres que nous étudions ici sont construits exclusivement à partir de bascules D assemblées en parallèle.

Dès lors, deux solutions s'offrent à nous :

Construire le registre à l'aide d'une boucle de génération de bascules D.

Construire le registre à partir d'une description comportementale séquentielle, comme nous l'avons fait pour la bascule D.

=> Nous choisissons la seconde solution.

Cette dernière offre également deux possibilités, avec signal ou avec variable, que nous verrons toutes les deux.


68B. Registre

i. Introduction

ii. Entité



v. Simulation


69ii. Entité

L'entité s'écrit conformément comme celle de la bascule, sauf que les données sont désormais des vecteurs logiques paramétrés :


70B. Registre

i. Introduction

ii. Entité



v. Simulation



Nous allons utiliser une notation nouvelle. En effet, l’accès aux éléments d’un vecteur de bits peut se faire de différentes façons en VHDL.

accès direct : a(7) <= b(2);

accès par tranche : a(7 downto 5) <= b(2 downto 0);

accès par agrégat :

notation positionnelle :

a(1 to 3) <= (‘0’,’1’,’1’); b <=(‘1’,’1’,others=>’0’);

notation avec nommage :

a(4 downto 0) <= (3=>’1’,1=>’1’,others=>’0’);


73B. Registre

i. Introduction

ii. Entité


iv.Architecture séquentielle avec variable

v. Simulation


74iii. Architecture séquentielle avec variable


75B. Registre

i. Introduction

ii. Entité



v. Simulation


76v. Simulation

L'entité comporte cette fois-çi un paramètre (N) qui sera attribué au composant testé (regN).


77v. Simulation

L'architecture déclare les signaux et instancie le composant à tester.


78v. Simulation

Puis, elle génère les valeurs qui seront affectés aux signaux, et donc aux ports d'entrée du composant à tester.


79v. Simulation

Chronogrammes



A. Bascule D

B. Registre




81C. Registre à décalages

i. Introduction

ii. Entité


iv. Simulation


82i. Introduction

Un registre à décalage est un registre classique, auquel on ajoute une fonction de décalage.

Il présente ainsi deux signaux de contrôle en plus du reset et de clk:

load : provoque le chargement du registre lorsqu'il vaut '1'.

shift : provoque le décalage de la donnée contenue dans le

registre et préalablement chargée lorsqu'il vaut '1'.

Généralement, le chargement (load) est prioritaire sur le décalage (shift).

Il existe plusieurs sortes de décalages.

De plus, la distance du décalage dépend de l'application réalisée.


83i. Introduction

Voici quelques exemples avec une distance de 1 bit :

À gauche À droite

Rotation

Décalage

Décalage



i. Introduction

ii. Entité


iv. Simulation


85ii. Entité

Les données sont paramétrées



i. Introduction

ii. Entité


iv. Simulation



reset : Il est prioritaire sur l'horloge. Il est donc asynchrone.

clk : Il cadence le fonctionnement du registre sur ses fronts montants.

load : Il est consulté suite au front actif de clk, il est donc synchrone.

shift : Il est également synchrone. En revanche, il n'est testé que si load

vaut '0'. Il est donc moins prioritaire.



i. Introduction

ii. Entité


iv.Simulation


90iv. Simulation


91iv. Simulation


92iv. Simulation


93iv. Simulation



A. Bascule D

B. Registre




95D. Compteur/décompteur

i. Introduction

ii. Entité


iv. Simulation


96i. Introduction

Un compteur/décompteur est un circuit logique séquentiel dont la valeur s'incrémente ou se décrémente au rythme de l'horloge (clk).

Pour cela, il faut une valeur initiale qui peut être chargée comme dans un registre, si le registre a une entrée de chargement (load). Sinon le compteur/décompteur est simplement initialisé à zéro (reset).

Le compteur/décompteur travaille sur un nombre de bits fixe, ce qui détermine un intervalle de valeurs représentables.

Arrivé aux limites de cet intervalle le compteur peut être bloqué, s'il possède un circuit de détection des limites. Sinon, il fait un dépassement de capacité, c'est à dire qu'il passe d'une limite de l'intervalle, à l'autre.


97i. Introduction

Nous allons considérer ici le cas d'un compteur/décompteur avec détection des limites.

La valeur initiale sera toujours nulle et fixée par le signal reset (pas de chargement).

Le choix du sens du comptage s'effectuera en fonction de la valeur du signal up_down :

'1' : le compteur/décompteur compte.

'0' : le compteur/décompteur décompte.

Enfin, les front montants de l'horloge seront validés par un signal enable.



i. Introduction

ii. Entité


iv. Simulation


99ii. Entité

Nous obtenons donc l'entité suivante :



i. Introduction

ii. Entité


iv. Simulation



Les tests de enable, de up_down et des limites de l'intervalle sont tous regroupés ensembles.

Seul le test du front d'horloge reste isolé, afin de garantir une interprétation correcte du code VHDL au moment de la synthèse.



i. Introduction

ii. Entité


iv.Simulation


104iv. Simulation


105iv. Simulation


106iv. Simulation


107iv. Simulation


108iv. Simulation


109iv. Simulation

modules vhdl

Documents