TUTO VHDL - Valentin Couteau

1) Un exemple

simple Le
schéma de la figure 1 correspond au comportement simulé ci-dessus car ils sont logiquement
équivalents et donnent les mêmes sorties S1 et S2.

2) Description structurelle ou comportementale

Après modication de l'architecture 1 par l'architecture 2, on remarque que les deux schémas issus de RTL
VIEWER sont identiques

Ci dessus se trouve le schéma de l'architecture 2 pour des signaux d'entrée aléatoires.

Ci dessus se trouve le schéma de l'architecture 1 pour des signaux d'entrée aléatoires.

On remarque que les résultats des deux simulations fonctionnels sont les mêmes car ils renvoient
l'inverse de l'entrée.

3) Notion de signal

Voici ci dessus le schéma fonctionnelle de l'architecture 3. On remarque encore une fois qu'il est
identique à celui de l'architecture 2. Les deux schémas issus de RTL Viewer sont eux aussi identiques,
seuls le nom des composants change. Cela permet de rendre le code plus lisisible.
4) Bus et nombres , opérateurs de test, opérateurs arithmétiques

Voici ci-dessus le schéma d'implantation du projet Combi1.

Voici ci-dessus le schéma fonctionnel du projet Combi1.

Le résultat de la simulation fonctionnelle est logique au vue du code VHDL. Par exemple pour S de 0 à
2us, on remarque bien 12 chiffres (11 DOWNTO 0) et en lisant les s(i) en partant de la droite on a bien :
s(8)<=0 car 0<8, s(9)<=1 car a=0, s(10)=0 car 0!=3 et s(11)<=1 car 0<8.

Voici ci-dessus le schéma d'implantation du projet Combi2.

et voici ci-dessus la simulation du schéma fonctionnel du projet combi2.

5) IF ... ELSE - Notion de process Résultat simulation fonctionnelle :

Sur l’intervalle de 0 à 2us :

On voit bien dans le premier cas comme c = 0, s prend la valeur de e(0) qui est nul donc
s est nul. Dans le deuxième cas e(0) vaut cette fois-ci 1 d’où s = 1.

6) INSTRUCTION CASE Résultat simulation fonctionnelle :

En zoomant sur l’intervalle de 0 à 2us :

La simulation fonctionnelle donne les mêmes résultats, car le code est équivalent.
Schéma RTL Viewer :

Un multiplexeur est un trapèze qui affiche les possibles valeurs des entrées (DATA[3..0],
SEL[1..0]).
Pour tester l’introduction d’un if dans un case on va créer un nouveau projet combi5. On
crée le code suivant :
On obtient le schéma RTL Viewer :

On réalise une simulation fonctionnelle :

On voit qu’avec les mêmes valeurs pour c et e, s dépend de val et si val est nul alors le
signal est lui aussi nul.Cependant si val est égal à 1 alors le multiplexeur fonctionne
normalement.
 7) Affectations sélectives

Schéma RTL Viewer :

Elles sont schématisées de la même manière par RTL Viewer. La première instruction
déclarée dans le code est concurrente alors que la seconde est séquentielle.
La première instruction va donc être plus rapide à l’exécution comme toutes les
situations possibles vont être effectuée en même temps alors que lors de la seconde si
par exemple ad n’est pas égal à 0, 1 ou 2 alors il faudra attendre la fin du code pour son
affectation.
L’instruction et le processus sont concurrents. 9. Boucle et variable de boucle
Il y a une erreur dans le code, il faut modifier PROCESS en PROCESS(a), on avait
oublié la sensitivity list.
Bilan intermédiaire sur le processus Logique séquentielle

1. Bascule D LATCH Schéma RTL Viewer :

Simulation fonctionnelle :

Initialement, aucune valeur n’est mémorisée. Puis lorsque ena est activée, on a bien la
sortie qui est égale à d.
Ensuite lorsque ena vaut 0, q ne prend pas la valeur de d et la prend seulement après
lorsque ena vaut 1, tout fonctionne donc normalement.
 2) Bascule D “Edge Triggered” Schéma RTL Viewer :

Simulation fonctionnelle :
Ce programme est plus rapide car si l’horloge ne passe pas de 0 à 1 alors on ne passe
même pas dans le process d’où un gain de temps comparé à l’autre code ou dans tous
les cas on entre dans le process.
3) Bascule D avec entrées asynchrones de pré-positionnement Voici le code réalisé
4) Registre parallèle Voici le code :
 6) Compteur Simulation fonctionnelle :
Le signal sortie est comme son nom l’indique, une sortie. Ainsi il serait impossible de
remplacer tampon par sortie comme on l’utilise avec par exemple l’opération : tampon
<= tampon + 1
Si on mettait sortie <= sortie + 1 on aurait une erreur comme on utiliserait sortie comme
une entrée.
On est donc obligé d’avoir un signal, “tampon”, qui nous sert à retenir la valeur du
signal.
Signal Mode Type Rôle - Fonctionnalité Type d’action

standard
h entrée Horloge qui régule la synchronisation synchrone
logic

raz c entrée bit Reset du compteur asynchrone

raz s entrée bit Reset lors d’un front montant synchrone

Permet le changement de sortie (chgt différent de

activation entrée bit synchrone
0)

up_down entrée bit Permet l’incrémentation du compteur synchrone

load_s entrée bit Sortie va prendre la valeur du nombre entree synchrone

entier Valeur que l’on peut attribuer à sortie selon

entree entrée synchrone
naturel load_s

entier
sortie sortie Compteur final asynchrone/synchrone
naturel

Sortie vaut 0 tant que l’on ne reset pas ou que

plein sortie bit asynchrone
l’on n’active pas load_s

pas de entier
tampon Signal qui nous sert à retenir les valeurs de signal asynchrone/synchrone
mode naturel

Graphe ou Machine d’états

Signal Mode Type Rôle - Fonctionnalité Type d’action

raz entrée standard logic Reset asynchrone

h entrée standard logic Horloge qui régule la synchronisation synchrone

x entrée standard logic Signal qui va permettre de modifier le signal “etat” synchrone

y entrée standard logic Signal qui va permettre de modifier le signal “etat” synchrone

z entrée standard logic Signal qui va permettre de modifier le signal “etat” synchrone

init entrée standard logic Reset synchrone synchrone

a sortie standard logic Permet de connaître l’état actuel de “etat” asynchrone

b sortie standard logic Permet de connaître l’état actuel de “etat” asynchrone

c sortie standard logic Permet de connaître l’état actuel de “etat” asynchrone

etat pas de mode STATE_TYPE Signal qui va changer d’état, élément principal asynchrone