Cours en ligne vhdl

Déclaration de l'entité

On commence par déclarer ce qu'on va décrire, ici une "entité" (un module, un bloc, un composant) : 

entity AND_3 is 

Le mot-clef entity est suivi du nom (ici AND_3), et de la liste des entrées-sorties du module
.
Ces entrées-sorties sont appelées ports. L'ordre des entrées-sorties n'a pas d'importance.
Contrairement au C et à Verilog, ll n'y a pas de distinction entre les majuscules et minuscules.

Puis viennent les déclarations du sens des ports :

• in pour les entrées du module
• out pour les sorties
• inout pour les ports bidirectionnels

il faut noter que chaque port est typé. Ici les ports sont de type bit , c'est  dire qu'ils peuvent prendre 2 états binaires. Au passage, on doit aussi déclarer la taille des ports. Par défaut, ils sont sur 1 bit. Pour un bus d'entrée A sur 8 bits, on aurait ce style de déclaration :

A : in bit_vector(7 downto 0); 

On aurait aussi pu déclarer
A : in bit_vector(0 to 7); mais il est plus naturel de positionner le MSB à gauche

Description de l'architecture

En VHDL le comportement du composant est décrit dans une Architecture contenant la partie interne du module. L'architecture doit être nommée, ici "arc" , ce qui permet de définir plusieurs architectures pour la même entité. Le code est défini entre les mots-clef begin et end

l'instruction <= est une instruction d'affectation qui se dit aussi "reçoit" permettant d'exprimer la causalité du calcul entre les entrées et la sortie combinatoire. Le mot-clef = existe aussi mais est utilisé comme opérateur de comparaison entre 2 variables.

Les expressions logiques utilisables sont propres à chaque type de variable. Pour le type prédéfini bit, les opérateurs utilisables sont les mêmes qu'en C :

• le ET est noté and
• le OU est noté or
• le XOR est noté xor
• le NON est noté not

Pour une porte NOR3, on aurait eu :

Déclaration des bibliothèques

Dans le langage VHDL de base, les fonctions arithmétiques ne sont disponibles que pour le type entier integer. Pour augmenter la richesse fonctionnelle du langage, comme par exemple effectuer des fonctions sur une signal quantifié, VHDL utilise les objets de bibliothèques préalablement compilées permettant d'introduire de nouveaux types et fonctions.  L'édition de lien, qui s'appelle "élaboration"en VHDL, utilise les bibliothèques déclarées dans le code avec le mot-clef library. La compilation qui s'appelle "analyse"en VHDL, est effectuée par défaut dans la bibiothèque work.

Les bibliothèques contiennent des objets dont la visibilité externe est assurée les par le biais des paquetages ou packages.

Le paquetage std_logic_1164 de la bibliothèque standard IEEE  définit le type std_logic qui correspond à un type énuméré sur 9 états. Ceci étoffe le réalisme du modèle par rapport au type bit qui n'a que 2 états binaires. Par exemple les états haute imédance 'Z' et inconnu 'X' font partie de ces 9 états.

Le paquetage numeric_std déclare et décrit des fonctions sur les variables de type std_logic , unsigned (vecteur de std_logic non signé), signed (vecteur de std_logic signé). Parmi celles ci figurent la plupart des fonctions arithmétiques, de comparaison et de conversion de type.

Déclaration de l'entité

Les directions des ports sont indiquées ici sous forme condensée en une seule ligne par type de port.

Description de l'architecture

Avec la bibliothèque IEEE et le paquetage numeric_std, les opérations arithmétiques se font sur des nombres de type unsigned (nombre non-signé composé de std_logic) ou signed (nombre signé composé de std_logic). Avant de décrire l'architecture, il est nécessaire de déclarer un signal intermédiaire, ici resultat, de type unsigned sur 2 bits pour pouvoir effectuer l'addition. 

L'architecture déclarée après le mot-clef begin consiste à coder le signal resultat en utilisant l'opérateur + et les entrées étendues à 2 bits du fait que l'opérateur + du paquetage numeric_std est homogène. L'extension à 2 bits se fait avec l'opérateur de concaténation & .
Les sorties s et cout sont donc extraites du signal resultat en considérant le bit de poids séparément conformément à l'algorithme d'addition   2*cout + s = a + b + cin.
Il faut noter qu'il n'est pas possible de coder directement s & cout car l'opérateur & est un opérateur binaire qui ne peut servir que dans l'expression d'affectation et non dan l'expression affectée.
 

Déclaration des bibliothèques nécessaires et de l'entité

Le module adder4 a 4 ports :

• a, b et s sur 4 bits
• cout sur 1 bit.

Les vecteurs étant non signés, il est nécessaire de déclarer préalablement la bibliothèque IEEE qui définit le type unsigned

Déclaration des composants et signaux nécessaires

L'additionneur 4 bits peut être compilé (on dit aussi "analysé") indépendamment de l'additionneur 1 bit. Il est donc nécessaire d'indiquer le composant "prototype" de l'additionneur 1 bit grâce au mot clé component de façon à l'utiliser dans l'architecture

Les instances des additionneurs 1 bits sont reliés entre eux : la retenue sortante de l'un est la retenue entrante du suivant.

Pour relier les additionneurs entre eux par la chaîne de retenue, on créée un signal c correspondant à un vecteur unsigned  constitué des 3 retenues internes. On aurait pu tout aussi bien déclarer 3 signaux de type std_logic. 

Instanciation des composants

On instancie un module de cette façon :

Chaque instance doit avoir un nom unique.

Pour relier le ports de l'instance aux signaux du module courant, on utilise ici la connexion par position : le premier signal est relié au premier port, le deuxième au deuxième, etc.

Cette façon de faire oblige à respecter l'ordre dans lequel les ports ont été déclarés.  Il existe une autre façon de relier les signaux, plus propre, elle sera étudiée plus tard.

De même il aurait été possible d'avoir une boucle de génération de code automatique qui aurait évité d'écrire 4 fois a peu près la même chose.

Déclaration des bibliothèques et de l'entité

La bibiothèque IEEE est déclarée pour utiliser le type std_logic ainsi que  la fonction rising_edge qui permet de détecter un front montant sur un signal . En logique synchrone, seul le signal d'horloge va utilser cette fonction.

Codage de l'architecure 

Le codage comportemental de la bascule fait appel à un processus. Un processus est un enchaînement d'instructions décrivant un comportement. Il possède une liste de sensibilité spécifiant sur quel signal le processus doit s'exécuter. Le processus en soit est une instruction concurrente mais son contenu est une suite d'instructions séquentielles. Il peut être utilisé aussi bien pour la logique séquentielle que pour la logique combinatoire.

Dans le cas de la logique synchrone faisant des calculs au rythme d'une horloge clk, la syntaxe est donc

process(clk).

Enfin, le corps du processus, codé entre begin et end, contient les instructions à exécuter. Pour une bascule D, cela consiste à recopier la valeur de l'entrée sur la sortie.
Il faut préalablement tester le front sur lequel l'exexution a lieu en utilisant l'instruction :
certains outils de synthèse ne respectant pas la prise en compte de la liste de sensibilité, il vaut mieux utiliser la syntaxe :
ou, si on utilise la bibliothèque IEEE :

Déclaration des bibliothèques et de l'entité

Le compteur dispose d'une entrée reset asynchrone resetn et d'une sortie q sur 8 bits.

Description de l'architecture

La décalration du signal interne q_int est nécessaire car q est un port de sortie , il ne peut donc pas être utilisé en entrée pour réaliser l'instruction de comptage
C'est q_int qui va donc servir à cette fin. Une autre solution aurait été de déclarer le port q de type buffer à la place de out, ce qui aurait évité l'utilisation de q_int.

La valeur du compteur peut changer sur deux événements :

• front montant de l'horloge
• état bas du reset

La liste de sensibilité doit donc contenir ces 2 signaux :

process(clk, resetn) 

Conformément à l'utilisation du reset asynchrone sur les bascule, le signal resetn est prioritaire par rapport au front d'horloge, il faut donc commencer le codage du processus par l'instruction 

if resetn='0' then

Il aurait été possible de mettre à 0 q_int par l'instruction q_int <= "00000000"; mais l'instruction q_int <= (others=> '0'); est plus générique. Il faut ensuite indiquer la condition sur le front montant de l'horloge pour déclencher le comptage :

elsif rising_edge(clk) then

Il faut noter que l'instruction de comptage s'effectue en additionnant un signal unsigned sur 8 bit avec un entier :

q_int <= q_int +1 

qui est une opération définie dans le paquetage numeric_std de IEEE. L'addition entre un unsigned et un std_logic n'est pas définie (donc l'écriture q_int <= q_int + '1' n'est pas possible)

Déclaration des bibliothèques et de l'entité

Le port d'entrée d_in rentre dans un registre à décalage de 8 bits qui sort sur d_out
La sortie match est activée à 1 lorsque l'entrée val est égale au contenu du registre à décalage.

Processus synchrone de décalage

Après avoir décalré le signal reg est nécesaire pour définir les 8 bascules internes nécessaires au décalage, un processus synchrone (donc sensible à clk) est utilisé.
Les instructions d'affectation utilisées dans le processus sont exécutées séquentiellement. L'execution consiste à remplir un échéancier d'affectation et non à affecter immédiatement le signal. Les affectations des signaux sont différées  elles ne prendront effet qu'une fois que tous les processus auront été exécutés, c'est à dire un temps symbolique après le front montant d'horloge dans notre cas.

Il aurait été possible de regrouper ces 2 instructions en une seule :

reg <= reg(6 downto 0) & d_in;

Processus combinatoires

La génération de la sortie match est un processus combinatoire, de même pour d_out, qui est équivalent à reg(7).

Ce module comporte en tout 3 processus :

• le bloc process, processus explicite
• les deux affectations concurrentes, processus implicites.

Tous les processus d'un module s'exécutent les uns en même temps que les autres. Mais l'intérieur du processus process est codé avec des instructions séquentielles.