MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

TD1:VHDL,tablesdevrit,diagrammed'volution
Nous allons prsenter dans ce chapitre les rudiments de programmation VHDL. Les descriptions abordes sont souvent qualifie de RT-level (Niveau Transfert de registres) car elles concernent en gnral des circuits utiliss autour des registres (addition,....)

ProgrammeVHDLsimple
Un programme VHDL est compos d'au moins un couple entit/architecture. Une autre faon de prsenter les choses est de dire que le programme minimum contient une entit et une architecture. Le rle de l'entit est de dclarer quelles sont les entres et comment elles s'appellent et la mme chose pour les sorties. Par exemple si l'on dsire dcrire une fonction ET :
1 2 3 4 5 6 7 8 9 ENTITY ET IS PORT(e0,e1 : IN BIT; --2 entrees appelees e0 et e1 s : OUT BIT); -- 1 sortie appele s END ET; ARCHITECTURE aET OF ET IS BEGIN s <= e0 and e1; -- equation de sortie END aET;

Programme 1: Un programme simple pour un et logique

Les lignes 1 4 dclarent l'entit et les lignes 6 9 dcrivent l'architecture. Tout programme VHDL contient au moins un couple entit architecture. On verra par la suite qu'il peut en contenir ventuellement plusieurs.

LesstylesdeprogrammationVHDLpourlecombinatoire
Nous prsentons la technique des BIT_VECTOR ainsi que l'ensemble des styles de programmation. Imaginons que l'on ait la table de vrit (4 entres 2 sorties) et l'entit correspondante : a3 a2 a1 a0 s1 s0 0 0 1 1 0 1 1 0 1 0 1 1 ENTITY demo IS PORT( a : in BIT_VECTOR(3 DOWNTO 0);-- 4 entres s : out BIT_VECTOR(1 DOWNTO 0)); -- 2 sorties END demo;

1 1 0 1 1 0 (ce qui n'est pas mentionn correspond 00 en sortie pour les 13 lignes manquantes)

Une table de vrit comporte deux parties : partie gauche appele partie SI qui doit donner l'ensemble des conditions possibles sur les entres et une partie droite appele partie ALORS donnant les valeurs des sorties. Le plus simple quand on a un cahier des charges sous forme d'une table de vrit est d'utiliser le constructeur VHDL "with select when". Il vous faut tout prix apprendre passer de l'un l'autre sans trop vous poser de questions, c'est dire comprendre le mcanisme de transformation. On remarquera, par exemple, que la partie SI se trouve gauche dans la table de vrit, mais droite dans le programme VHDL. Le programme VHDL en style "with select when" s'crit :

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

1 2 3 4 5 6 7 8

ARCHITECTURE mydemo OF demo IS BEGIN WITH a SELECT --style with select when s <= "11" WHEN "0101", -- premiere ligne "01" WHEN "0110", -- deuxieme ligne "10" WHEN "1101", -- troisieme ligne "00" WHEN OTHERS; END mydemo;

Programme 2: Le style with select when

Ce style est adapt aux tables de vrit. En effet tous deux ncessitent des conditions mutuellement exclusives dans la partie SI (pour la table de vrit) et dans la partie WHEN du WITH SELECT WHEN . Tous les deux ncessitent une description exclusive de toutes les possibilits, visible avec le WHEN OTHERS en ligne 7 du programme 2. On crirait le mme programme en style "when else" :
1 2 3 4 5 6 7 8 ARCHITECTURE mydemo OF demo BEGIN -- style when else s <= "11" WHEN a="0101" "01" WHEN a="0110" "10" WHEN a="1101" "00"; END mydemo; IS ELSE -- premiere ligne ELSE -- deuxieme ligne ELSE -- troisieme ligne

Programme 3: Combinatoire en style when else

Remarque : la structure "when else" ne ncessite pas de conditions mutuellement exclusives. Elle engendre alors une architecture avec priorit. Par exemple dans
1 2 3 j<= w when a='1' else x when b='1' else 0;

les conditions ne sont pas mutuellement exclusives. Qu'adviendra-t-il en effet si a='1' et b='1' arrivent simultanment ? (Rponse : j <= w : c'est le premier qui gagne). On ne pourrait pas utiliser dans ce cas directement une structure "with select when" qui ncessite des conditions absolument exclusives.
Le style case when peut tre aussi utilis (en combinatoire comme en squentiel, il ncessite un process dans les deux cas) :

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

1 2 3 4 5 6 7 8 9 10 11

ARCHITECTURE mydemo OF demo IS BEGIN PROCESS(a) BEGIN -- absolument necessaire CASE a is --style case when WHEN "0101" => s <="11"; -- premiere ligne WHEN "0110" => s <="01"; -- deuxieme ligne WHEN "1101" => s <="10"; -- troisieme ligne WHEN OTHERS => s <="00"; END CASE; END PROCESS; END mydemo;

Programme 4: Combinatoire avec style case when

Un autre style ncessite un process : if then else :

1 2 3 4 5 6 7 8 9 10 ARCHITECTURE mydemo OF demo IS BEGIN PROCESS(a) BEGIN IF a="0101" THEN s <="11"; -- premiere ligne ELSIF a="0110" THEN s <="01"; -- deuxieme ligne ELSIF a= "1101" THEN s <="10"; -- troisieme ligne ELSE s <="00"; END IF; END PROCESS; END mydemo;

Programme 5: Combinatoire avec style if then else

Conseil : utiliser le style with select when pour programmer du combinatoire si vous ne voulez pas tablir d'quations. Si vous disposez des quations utiliser-les en vous rappelant que VHDL n'a pas de priorits du ET sur le OU. Il vous faudra donc des parenthses.

Exercice 1
Write a VHDL program for a one bit adder using "with select when" style.

VHDLetlalibrairieIEEE
Les seuls types utiliss jusqu' maintenant sont les bit et bit_vector . Un bit prend seulement deux valeurs et ne permet pas de grer le trois tats par exemple. IEEE propose en supplment une librairie appele std_logic. Son utilisation ncessite l'criture des deux lignes suivantes
1 2 library ieee; use ieee.std_logic_1164.all;

Programme 6: dclaration et utilisation d'une librairie ieee

en dbut du programme qui l'utilise. On a alors accs aux types std_logic et std_logic_vector. Les valeurs prises par ces types sont :
4 5 6 7 8 'U' Uninitialised 'X' Forcing Unknow '0' Forcing 0 '1' Forcing 1 '-' -- Don't Care 'Z' 'W' High Impedance Weak Unknow 'L' Weak O 'H' Weak 1

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

On dispose de plus des fonctions rising_edge et falling_edge pour la dtection de fronts montants et descendants (au lieu des if clk'event...). Indication : il vous faudra crire les deux lignes d'utilisation de la librairie devant chaque entits si vous en avez plusieurs. Si vous avez un programme avec quatre entits, il vous faudra crire quatre fois ces lignes. Exercice 2 crire le programme de l'exercice 1 en utilisant la librairie IEEE.

Programmecomportantplusieurscomposants
Il existe plusieurs faons d'crire un programme comportant plusieurs composants. Quelque soit la mthode, vous commencez par compter les composants diffrents et vous en obtenez N. Si vous avez deux composants ET, vous ne le comptez qu'une seule fois. Il vous faudra un couple entit architecture par composant. Par exemple, le schma ci-dessous comporte N=3 composants (ET, OU, NON). Vous aurez crire autant de couples entit - architecture qu'il y a de composants plus un couple entit architecture pour la description globale. Vous aurez donc N+1 couples.

e0 e1 e2

i1

& 1
i2

e0e1 e2bar

i3

>1

Figure 1: Ensemble de trois composants

Cette programmation s'appelle structurelle et elle revient dcrire un schma ; dans la terminologie lectronique cela s'appelle aussi une netlist. Une mthode consiste utiliser un seul fichier.

Utiliserunseulfichierpourmettreplusieurscomposants
L'utilisation d'un seul fichier se fait en dclarant des signaux et des composants avant le begin de l'architecture globale. Voici l'exemple de la figure 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ENTITY Fct IS entit globale PORT(e0,e1,e2 : IN BIT; s : OUT BIT); END Fct; ARCHITECTURE truc OF Fct IS -- signaux et composants avant le begin de l'architecture SIGNAL e0e1,e2bar : BIT; COMPONENT et PORT(e0,e1 : IN BIT; s : OUT BIT); END COMPONENT; COMPONENT ou PORT(e0,e1 : IN BIT; s : OUT BIT); END COMPONENT; COMPONENT inverseur PORT(e : IN BIT;

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon) 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 s : OUT BIT); END COMPONENT; BEGIN i1:et PORT MAP(e0=>e0,e1=>e1,s=>e0e1); i2:inverseur PORT MAP(e=>e2,s=>e2bar); i3:ou PORT MAP(e0=>e0e1,e1=>e2bar,s=>s); END truc; -- fin de l'architecture globale ENTITY et IS PORT(e0,e1 : IN BIT; s : OUT BIT); END et; ENTITY ou IS PORT(e0,e1 : IN BIT; s : OUT BIT); END ou; ENTITY inverseur IS PORT(e : IN BIT; s : OUT BIT); END inverseur; ARCHITECTURE aet OF et IS BEGIN s<=e0 AND e1; END aet; ARCHITECTURE aou OF ou IS BEGIN s<=e0 OR e1; END aou; ARCHITECTURE ainv OF inverseur IS BEGIN s<= NOT e; END ainv;

Utiliserdeuxfichiersdontunpackage
Lors du TD2 de ENSL1 (assemblage de fonctions) nous avons pass sous silence le fait que pour faire la description structurelle prsente il fallait utiliser notre propre package dfinissant ce qu'est un et, un ou et un inverseur. Nous crivons ci-dessous la version complte du programme, on commence par le fichier principal :
1 2 3 4 5 6 7 8 9 10 11 12 13 USE work.mesportes.ALL; ENTITY Fct IS PORT(e0,e1,e2 : IN BIT; s : OUT BIT); END Fct; ARCHITECTURE truc OF Fct IS SIGNAL e0e1,e2bar : BIT; BEGIN i1:et PORT MAP(e0=>e0,e1=>e1,s=>e0e1); i2:inverseur PORT MAP(e=>e2,s=>e2bar); i3:ou PORT MAP(e0=>e0e1,e1=>e2bar,s=>s); END truc;

Programme 7: Fichier principal pour l'entit globale

La gestion des librairies dpend beaucoup de l'environnement dont vous disposez. Chaque fois que vous en utilisez une vous devez vous poser la question de savoir comment votre compilateur sait dans quel fichier il va trouver votre package. Ci-dessus (programme 7), est prsent la faon simple de l'environnement Xilinx : c'est le gestionnaire de projet dans lequel est rentr tous les fichiers sources qui 5

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

est capable de trouver o est le package mesportes. Avec l'environnement Warp (Cypress), le gestionnaire de librairie doit connaitre o est le fichier librairie (qui est compil). L'entte est alors :
1 2 3 LIBRARY portes; --portes.vif en WARP. Utiliser --library manager pour dire o est ce fichier USE portes.mesportes.ALL;

Et voici en condens comment on ralise un package. La partie package dclare les composants (component) et le corps du fichier va comporter les entits et architectures des composants. Le fichier dfinitif aura donc la forme suivante :
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 PACKAGE mesportes IS COMPONENT et -- tout cela est visible dans un .ALL PORT(e0,e1 : IN BIT; s : OUT BIT); END COMPONENT; COMPONENT ou PORT(e0,e1 : IN BIT; s : OUT BIT); END COMPONENT; COMPONENT inverseur PORT(e : IN BIT; s : OUT BIT); END COMPONENT; END mesportes; --********** fin du package *********** ENTITY et IS --********** debut implantation *********** PORT(e0,e1 : IN BIT; s : OUT BIT); END et; ENTITY ou IS PORT(e0,e1 : IN BIT; s : OUT BIT); END ou; ENTITY inverseur IS PORT(e : IN BIT; s : OUT BIT); END inverseur; ARCHITECTURE aet OF et IS BEGIN s<=e0 AND e1; END aet; ARCHITECTURE aou OF ou IS BEGIN s<=e0 OR e1; END aou; ARCHITECTURE ainv OF inverseur IS BEGIN s<= NOT e; END ainv;

Faire de l'lectronique l'ancienne, c'est assembler des fonctions toutes faites pour en composer de nouvelles et assembler ces nouvelles pour en raliser des encore plus complexes et ainsi de suite. On voudrait retrouver cette faon de faire avec VHDL. Ce qui fait la difficult d'utiliser VHDL, c'est qu'il n'y a aucun composant prdfini : mme les ET, OU ... ne sont pas prdfinis (contrairement verilog, le concurrent de VHDL, qui dfinit AND, NAND, OR, et NOR). A noter quand mme une initiative VHDL avec LPM (Library of Parameterized Modules) que malheureusement Xilinx n'utilise pas.

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Lesquentiel
Le squentiel dispose lui-aussi de ses propres styles. L'quivalent de la table de vrit (spcification sans quation) est le diagramme d'volution. Il est possible ici encore d'utiliser soit les quations (de rcurrence alors) soit le diagramme d'volution. Nous prsentons les deux styles maintenant. Ils sont caractriss par la dtection d'un front montant sur une horloge.

Lesquentielsimple(diagrammed'volution)avecquationsdercurrence
Dans cette section, on ne s'intresse qu'aux diagrammes d'volution simples c'est dire avec des transitions inconditionnelles. Les diagrammes d'volutions un peu plus complexes sont traits plus loin (chapitre 3). On tablit d'abord un tableau tat prsent tat futur duquel on dduit des quations de rcurrences. La mthode est prsente sur un exemple. Nous commenons par le graphe d'volution (avec ses 4 tats et 4 flches transitions) :

00

01

11

10

Figure 2: Diagramme d'volution sur quatre tats

Puis le tableau tat prsent / tats futurs ainsi que le tableau de Karnaugh associs sont prsents :

tatprsenttatfutur Q1Q0Q1+Q0+ 0001 0110 1011 1100

Q0 Q101 001 110 Q1+

Q0 Q101 010 110 Q0+

quationsdercurrence: Q1+=Q1XORQ0 Q0+=/Q0

Figure 3: Tableau tat prsent / tat futur et ses quations de rcurrences

Cela donne le programme :

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 -- compteur premiere version ENTITY cmpt IS PORT ( clk: IN BIT; q0,q1: BUFFER BIT); -- BUFFER dconseill dans un PORT par Xilinx END cmpt; ARCHITECTURE acmpt OF cmpt IS BEGIN PROCESS (clk) BEGIN IF (clk'EVENT AND clk='1') THEN q0 <= NOT q0; q1 <= q0 XOR q1; END IF; END PROCESS; END acmpt;

Programme 8: Le squentiel simple avec quations de rcurrences : un compteur

o les deux quations de rcurrences se trouvent en ligne 10 et 11 encadres par une dtection de front d'horloge.

Lesquentielsimple(diagrammed'volution)sansquationsdercurrence
La programmation d'un diagramme d'volution se fait directement partir du tableau tat prsent / tat futur comme le montre le code VHDL ci-dessous (programme 9) :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 -- compteur deuxieme version voir programme 8 ENTITY cmpt IS PORT ( clock: IN BIT; q : BUFFER BIT_VECTOR(1 DOWNTO 0)); END cmpt; ARCHITECTURE mydemo OF cmpt IS BEGIN PROCESS(clock) BEGIN IF clock'EVENT AND clock='1' THEN CASE q IS --style case when WHEN "00" => q <="01"; WHEN "01" => q <="10"; WHEN "10" => q <="11"; WHEN OTHERS => q <="00" ; END CASE; END IF; END PROCESS; END mydemo;

Programme 9: Le squentiel simple sans quations de rcurrences : toujours le mme compteur

Xilinx : Do not use buffers when a signal is used internally and as an output port. Pour viter les BUFFER dans les PORTS, utiliser un signal interne.

Exercice 3
Raliser un compteur GRAY sur 3 bits en utilisant ces deux mthodes et sans BUFFER.

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

TD2:Squentielrgulier:compteursetregistres
Le squentiel consiste toujours calculer un tat futur partir d'un tat prsent. Le terme calcul est employ ici de manire trs gnrale, au sens boolen ou au sens arithmtique ou autre. Lorsque ce calcul s'crit avec un oprateur simple on parlera de squentiel rgulier. Parmi les oprateurs simples on trouve l'incrmentation qui donne lieu des compteurs. Ils permettent de grer tout ce qui est temporisation et videmment comptage. Un autre oprateur simple est la concatnation (mise en bout bout) ralise en VHDL avec l'oprateur et commercial & . Il nous permettra de raliser les registres dcalage.

Lecompteursimple
Il est possible d'utiliser un style case pour programmer un compteur mais cela devient vite fastidieux lorsque le nombre de bits augmente. On multiplie par deux le nombre d'tats chaque fois que l'on ajoute un bit. Exercice 1 Combien d'tats comporte un compteur de n bits et donc combien de lignes pour chacun des case ? Application numrique : prendre n=16. L'idal serait donc de pouvoir crire quelque chose du style
1 compteur <= compteur + 1;

Cela peut se faire en respectant les conditions suivantes :

utilisation de la librairie IEEE 1164 utilisation de la librairie IEEE ARITH utilisation de la librairie IEEE UNSIGNED dclaration de compteur comme std_logic_vector

Avec XILINX cela se fait avec les lignes (devant chacune des entits concernes) :
1 2 3 4 5 library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; -- WARP : use work.std_arith.all; use ieee.std_logic_unsigned.all;

Programme 10: Utilisations des packages Xilinx (non portables)

Mais cette faon de faire n'est pas portable comme le montre le commentaire. En fait les packages "std_logic_arith" et "std_logic_unsigned" semblent ne pas appartenir la norme IEEE contrairement ce que semblerait indiquer leur nom dans le programme 10.
1 2 3 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all;

Programme 11: Utilisations des packages IEEE (portables)

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Les trois lignes du programme 11 semblent plus portables mais ncessitent de changer systmatiquement la faon de compter. Il faut alors transformer
1 compteur <= compteur + 1;

en
1 compteur <= std_logic_vector(unsigned(compteur) + 1);

Exercice 2 Vous disposez d'une horloge rapide et vous voulez raliser en raliser une plus lente dont la frquence est divise par 32768. Proposez un compteur avec comme entre h_rapide et comme sortie h_lente (toutes deux sur un bit). Le compteur intermdiaire sera ralis par un signal.

Possibilitd'utiliserunsignaldetypeinteger
Dans ce cas le compilateur peut avoir des problmes pour trouver le nombre de bits ncessaires pour le compteur. Il faudra donc utiliser une comparaison supplmentaire :
1 2 3 4 5 6 7 8 9 architecture a_cmpt of cmpt is signal Count : integer :=0; process(Clk) begin if (Clk'event and Clk='0'); if (Count=7) then Count <=0; -- sur 3 bits else Count <=Count+1; end if; end process; end a_cmpt;

Programme 12: utilisations du type integer dans un compteur

CompteuravecRemisezro(raz)
L'entre raz sur un compteur est une entre qui permet de mettre la valeur du compteur 0. Elle peut tre synchrone (prise ne compte seulement sur front d'horloge) ou asynchrone. Commenons par l'entit qui nous servira pour nos deux styles de forage.
1 2 3 4 5 6 7 8 9 library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; ENTITY Compteur IS PORT ( clk,raz :IN std_logic; q : BUFFER std_logic_vector(3 downto 0)); END Compteur;

Programme 13: Entit gnrale d'un compteur (avec les packages IEEE)

Nous allons prsenter tour tour la mthode synchrone d'abord puis la mthode asynchrone.

10

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Mthodesynchrone
La mthode synchrone consiste raliser le raz (remise zro) dans le front d'horloge. Nous en prsentons les lments essentiels dans le programme ci-dessous.
1 2 3 4 5 6 7 8 9 PROCESS(clk) BEGIN IF clk'event and clk='1' THEN IF raz='1' THEN q<=(OTHERS=>'0'); ELSE q<=std_logic_vector(unsigned(q)+1); END IF; END IF; END PROCESS;

Programme 14: Raz synchrone pour un compteur

Remarquez le (OTHERS=>'0') en ligne 4 qui permet de remettre le compteur zro quelque soit son nombre de bits. L'criture q<=''0000'' ncessite de savoir qu'il y a 4 zros dans la chaine de caractres. Quant au IF raz de la ligne 3 il se trouve bien l'intrieur du IF clk'event de la ligne prcdente. Bien sr ce process est mettre dans une architecture.

Mthodeasynchrone
La mthode asynchrone consiste raliser le raz (remise zro) en dehors du front d'horloge. Ce signal devient alors prioritaire.
1 2 3 4 5 6 7 PROCESS(clk,raz) BEGIN IF raz='1' THEN q<=(OTHERS=>'0'); ELSIF clk'event and clk='1' THEN q<=std_logic_vector(unsigned(q)+1); END IF; END PROCESS;

Programme 15: Raz asynchrone pour un compteur

Remarquez en ligne 1 que la liste de sensibilit du process comporte maintenant l'entre raz en plus de l'horloge. Exercice 3 Raliser un compteur avec SET et RESET synchrones et asynchrones. Modifier ce compteur pour qu'il compte jusqu' 24.

Compteuravecchargementparallle
Le chargement parallle est en gnral asynchrone. L'entit devra possder les entres de prpositionnement du compteur. Cela peut se raliser comme dans le listing suivant pour l'architecture de ce compteur :

11

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

1 library ieee; 1 ARCHITECTURE acmpt OF Compteur IS BEGIN 2 use ieee.std_logic_1164.all; 2 PROCESS(clk,load) BEGIN 3 use ieee.numeric_std.all; 3 IF load='1' THEN 4 ENTITY Compteur IS 4 q<=qe; 5 PORT ( 5 -- ou q<=31; valeur predefinie 6 clk,load :IN std_logic; 6 ELSIF clk'event and clk='1' THEN 7 q : BUFFER std_logic_vector(3 downto 0) 7 q<=std_logic_vector(unsigned(q)+1); 8 qe : IN std_logic_vector(3 downto 0)); 8 END IF; 9 END Compteur; 9 END PROCESS; 10 END acmpt; Programme 16: Entit d'un compteur avec chargement parallle Programme 17: Architecture d'un compteur avec chargement parallle

Temporisation
L'application la plus courante des compteurs est la temporisation. Exercice 4 On dsire raliser les deux signaux hsynch et vsynch ncessaire au bon fonctionnement d'un cran VGA. Ils sont caractriss par les dures suivantes :

Une ligne Pixels RGB 1,54 us 3,8 us 25,6 us 31,75 us 480 lignes 1,02 ms 15,24 ms 64 us 0,35 ms vsynch 0,64 us

hsynch

16,6 ms
Figure 4: Chronogramme VGA

Techniquement la ralisation est faite de la manire suivante :

12

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

25MHz P88

0 -> XXX
hcnt

ZZZ<hcnt<TTT

hsynch

0 -> YYY
vcnt

UUU<vcnt<VVV

vsynch

Figure 5: Ralisation matrielle de la synchronisation VGA

On voit apparatre deux compteurs et une partie combinatoire de comparaison qui doit tre synchronise. 1) Calculer la priode de P88. 2) Le compteur 0 -> XXX commence compter au dbut des 25,6 s. Jusqu' combien doit-il compter pour raliser ces 25,6 s ? 3) Il lui faut raliser ensuite 0,64 s, jusqu' combien doit-il compter ? Il lui faut raliser ensuite 3,8 s, jusqu' combien doit-il compter ? Il lui faut raliser ensuite la priode complte 31,75 s, jusqu' combien doit-il compter ? (C'est la valeur de XXX un prs) On arrondit en gnral XXX 799. Dduire de tout cela la valeur de ZZZ et TTT. 4) Ce sont les hsynch qui incrmentent le compteur 0->YYY. Quelle est la priode correspondante (si l'on prend XXX=799) ? 5) Combien de temps dure alors la priode des 480 lignes avec le rsultat de la question 4 ( comparer 15,24 ms de la spcification VGA). 6) A l'aide du rsultat de 4) trouver de combien doit compter le compteur pour raliser le temps de 0,35 ms. 7) A l'aide du rsultat de 4) trouver de combien doit compter le compteur pour raliser le temps de 64 s. 8) A l'aide du rsultat de 4) trouver de combien doit compter le compteur pour raliser la priode complte de 16,6 ms. Est-il normal d'arrondir 520 ? 9) Dduire les valeurs de UUU et VVV

Registredcalage
L'oprateur de concatnation & est utile pour ce genre de registre : Le programme 18 dcrit un registre dcalage droite.

13

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

-- registre dcalage library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity ShiftReg is port(clk,entree : in std_logic; q : out std_logic_vector(7 downto 0)); end ShiftReg; architecture aShiftReg of ShiftReg is signal dataq : std_logic_vector (7 downto 0); begin process(clk) begin if clk'event and clk='0' then dataq <= entree& dataq(7 downto 1); end if; end process; process(dataq)begin q<=dataq; end process; end aShiftReg;

Programme 18: Un registre dcalage complet

Exercice 5 (filtrage de rebonds) Cet exercice dcrit une partie d'un TP que l'on peut trouver en http://fr.wikiversity.org/wiki/Very_High_Speed_Integrated_Circuit_Hardware_Description_Language particulirement au TP2. L'architecture peut tre dcrite comme suit : un registre dcalage 4 bits sensible aux fronts descendants de T9, une bascule D qui mmorise l'tat de notre sortie et une partie combinatoire qui gnre un 1 l'entre de la bascule D ds que le registre est rempli par 4 bits 1 et que sortie vaut 0. Complter les chronogrammes.

PS2_clk T9

Registre dcalage Q3 Q2 Q1 Q0 F Si eQ=0 Si eQ=1 F=Q3.Q2.Q1.Q0 F=Q3+Q2+Q1+Q0

Figure 6: Filtage anti-rebonds

D clk

Sortie

eQ

14

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon) T9 PS2_clk Q3 Q2 Q1 Q0 F Sortie T9 PS2_clk Q3 Q2 Q1 Q0 F Sortie Figure 7: Chronogrammes complter

Le principe est le suivant : le registre dcalage chantillonne les entres PS2_clk. Si la sortie de la bascule D est zro, F passera un quand les 4 valeurs du registres seront un (autrement dit pas de prsence de zro donc pas de rebond). Le OU pour le F quand eQ est un a pour objectif de supprimer les rebonds un car il faut que toutes les entres Qi soient zro pour que le F passe zro.
T9 PS2_clk Q3 Q2 Q1 Q0 F Sortie T9 PS2_clk Q3 Q2 Q1 Q0 F Sortie Figure 8: Chronogrammes complter (suite)

15

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

TD3:VHDLetlogiquesquentiellenonrgulire
Nous allons nous intresser dans ce chapitre aux machines squentielles simples et leur programmation en VHDL. Le style de programmation est assez proche de celui des compteurs au moins en ce qui concerne les initialisations synchrones ou asynchrones. Un automate fini (on dit parfois machine tats finis ou encore machine squentielle), en anglais finite state automaton ou finite state machine (FSA, FSM), est une machine abstraite utilise pour spcifier la logique squentielle.

Programmationdegraphesd'tatsetgraphesd'volutions
Dans toute la suite de ce document, on dsignera par graphe d'volution un ensemble d'tats nots par des ronds et un ensemble de flches reliant ces tats. Ces flches seront maintenant indices par des conditions sur les entres. C'est ce qui diffrencie les exemples du premier chapitre (Figure 2 et Programme 9) avec ce que l'on se propose d'expliquer dans ce chapitre. Un graphe d'tats sera un peu similaire sauf que les transitions seront rceptives : cela se note avec un trait qui barre la transition et la signification de ce trait est donne dans le figure 9.

Key=1
Ring =0 Arme d Off

Key=0
Ring =0 Off

Key=1
Arme d Ring ing Ring =1

Off

Armed

Ring =0

Off

Armed

Figure 9: Graphe d'tat et son quivalent en graphe d'volution

Un graphe d'tat est une suite d'tats et de transitions rceptives. tats Transitions

1
inactif

1
actif

1
initial

a+b.c

Rceptivit

Pour bien comprendre la diffrence entre les deux types de graphe nous allons donner un exemple. Commenons par le graphe d'volution : nous avons choisi un graphe de trois tats avec la reprsentation utilise par certains logiciels qui permettent en plus la dclaration des entres et des sorties. A noter aussi comment sont spcifies les sorties dans ce graphe d'tat (ici la sortie unique s'appelle s ). Le graphe d'volution est donc plus sophistiqu que celui de la figure 2 et le programme qui en rsultera aussi.

16

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

ds0203 //diagram ACTIONS

e0 e1 Init clock

Sreg0 s<='0 e0='1' ' etat0 etat1

e0='0'

e1='0'

Init='1'

e0='1'

s<='1'

e1='1'

etat2

s<='0'

e0='0' Figure 10: Exemple de diagramme d'volution

Comme graphe d'tat, nous choisissons un exemple qui sera dtaill plus loin :

1 e4 2 e2 3 a3 e1 a4

a1a2 e1 4 e3 a3

Figure 11: Exemple de graphe d'tat

Dans cet exemple, nous avons quatre tats, trois entres e1, e2 et e3 et quatre sorties a1, a2, a3 et a4.

Lesgraphesd'volutionsetlestylecasewhen
Prsentons d'abord la technique de programmation avec et sans initialisation. Commenons par la programmation sans initialisation. Le principe consiste dclarer d'abord un type numr avec une dfinition symbolique de chacun des tats (ici Armed, Off, Ringing) :

1 1

TYPE typetat IS (Armed, Off, Ringing); -- dans architecture SIGNAL etat : typetat;

Programme 19: Dfinition symbolique des tats et du signal correspondant

Ensuite dans un case when on dtaillera toutes les transitions possibles comme montr ci-dessous dans le cas o l'on ne s'intresse pas une initialisation : 17

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

1 2 3 4 5 6 7 8 9 10 11 12 13

-- sans initialisation BEGIN PROCESS (clock) BEGIN IF clock'EVENT AND clock='1' THEN CASE etat IS WHEN Off => IF key ='1' THEN etat <= Armed; ELSE etat <= Off; END IF; .... END CASE; END IF; END PROCESS; ....

Programme 20: Utilisation du style case dans une programmation de transitions

L'ide gnrale est donc d'utiliser un case sur les tats avec des if pour grer l'ensemble des transitions. L'ajout d'une initialisation synchrone se fait dans le "if clk'event" comme indiqu ci-dessous :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 -- avec initialisation synchrone BEGIN PROCESS (clock) BEGIN IF clock'EVENT AND clock='1' THEN IF Init='1' THEN etat <=Off; --initialisation synchrone ELSE CASE etat IS WHEN Off => IF key ='1' THEN etat <= Armed; ELSE etat <= Off; END IF; .... END CASE; END IF; END IF; END PROCESS; ....

Programme 21: Utilisation du style case et d'une initialisation synchrone

Comme pour les compteurs, l'initialisation asynchrone se fait elle, avant le "if clk'event" sans oublier d'ajouter l'entre d'initialisation (ici reset) dans la liste des sensibilits du process correspondant.

18

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

-- avec initialisation asynchrone BEGIN PROCESS (clock,reset) BEGIN IF Init='1' THEN etat <=Off; --initialisation asynchrone ELSIF clock'EVENT AND clock='1' THEN CASE etat IS WHEN Off => IF key ='1' THEN etat <= Armed; ELSE etat <= Off; END IF; .... END CASE; END IF; END PROCESS; ....

Programme 22: Utilisation du style case et d'une initialisation asynchrone

Notez en ligne 5 l'utilisation d'un "elsif" en lieu et place d'un "else if" dont l'intrt est d'conomiser un "end if".

Lecodagedestats
La programmation des tats ncessite une dclaration symbolique comme on peut voir ci-dessous :
1 2 TYPE typetat IS (Armed, Off, Ringing); -- dans architecture SIGNAL etat : typetat;

Quand la synthse sera demande plusieurs solutions peuvent se prsenter suivant le codage des tats. Une telle dclaration dbouchera sur un codage Armed=00, Off=01 et Ringing=10. On peut modifier ce codage l'aide de deux attributs diffrents : enum_encoding et state_encoding. Enum_encoding est normalis par le standard IEEE 1076.6.
1 2 type state is (s0,s1,s2,s3); attribute enum_encoding of state:type is "00 01 10 11";

La directive state_encoding spcifie la nature du code interne pour les valeurs d'un type numr.
1 attribute state_encoding of type-name:type is value;

Les valeurs lgales de la directive state_encoding sont sequential, one_hot_zero, one_hot_one, and gray. sequential : on code en binaire au fur et mesure de l'numration avec autant de bits que ncessaire. one_hot_zero : on code la premire valeur par zro, puis le reste en utilisant chaque fois un seul un : N tats ncessiteront donc N-1 bits. one_hot_one : idem one_hot_zero sauf que l'on n'utilise pas le code zro. N tats ncessiteront donc N bits. Gray : les tats suivent un code GRAY. Exemples :
1 2 type state is (s0,s1,s2,s3); attribute state_encoding of state:type is one_hot_zero;

19

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

et
1 2 type s is (s0,s1,s2,s3); attribute state_encoding of s:type is gray;

Exercice 1
Design a state machine that detects, starting with the left most bit, the sequence 1111010 . a) Draw the state flow diagram b) Find the corresponding sequential functions with state encoding and the VHDL program. La connaissance du codage des tats permet de trouver les quations de rcurrences.

Programmationdesgraphesd'tatsparquationsdercurrences
Aprs avoir examin la programmation des graphes d'volution avec un style case when nous allons nous intresser dans cette section la programmation des graphes d'tats par les quations de rcurrences. Cette faon de prsenter les choses pourrait laisser penser que le style de programmation VHDL est li au type de graphe que l'on utilise. Ceci est naturellement faux, puisqu'il est facile de passer d'un graphe d volution un graphe d'tats et inversement, comme on l'a montr en tout dbut de ce chapitre avec la figure 9. D'autre part, dans le chapitre I, la section Le squentiel nous a montr comment on pouvait utiliser les deux styles pour un graphe d'volution simple. Nous allons donc commencer par rappeler comment on passe d'un graphe d'tats des quations de rcurrences.

1 e4 2 e2 3 a3 e1 a4

a1a2 e1 4 e3 a3

Figure 12: Notre graphe d'tat d'exemple

On cherche pour chacun des tats i les conditions d'activations ACi et les dactivations Di puis on crit :

x i = ACi Dix i
pour chacun des tats. Pour notre exemple cela donne : AC1 AC2 AC3 AC4 = = = = x3.e4+x4.e3 x1.e1 x2.e2 x1./e1 D1 D2 D3 D4 = = = = e1+/e1=1 e2 e4 e3

et donc comme quations :

20

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

quations de rcurrences x1+ = x3.e4+x4.e3 x2+ = (x1.e1+x2./e2) x3+ = (x2.e2+x3./e4) x4+ = (x1./e1+x4./e3)

quations de sorties a1 a2 a3 a4 = = = = x1 x1 x3 + x4 x2

On a ajout pour tre complet les quations de sorties.

Lesforagessynchronesetasynchronesaveclesquationsdercurrences
Tout graphe d'tat ou graphe d'volution peut donc tre transform en un ensemble d'quations de rcurrences. En gnral cette transformation prend en compte le codage des tats que l'on vient d'voquer. On retrouve les deux faons pour initialiser, celle qui utilise les fronts d'horloge (synchrone) et celle qui ne les utilise pas (asynchrone).

Initialisationasynchronepartirdesquationsdercurrences
L'asynchrone ressemble normment ce que l'on a dj prsent et ne ncessite pas d'explications supplmentaires.
1 2 3 4 5 6 7 8 9 -- gestion de l'asynchrone process(clk,reset) begin if reset='1' then -- avant horloge donc asynchrone q<="0000"; -- ou q <=(OTHERS =>'0'); elsif clk'event and clk='1' then -- ici le synchrone : quations de rcurrences end if; end process;

Programme 23: Initialisation asynchrone et quations de rcurrences

Remarquons que le signal q est un std_logic_vector initialis "0000" (ce qui n'est pas ordinaire lorsqu'on utilise des quations de rcurrences). Il comporte donc quatre bits et il y aura donc quatre quations de rcurrences pour q(0), q(1), q(2) et q(3).

Initialisationsynchronepartirdesquationsdercurrences
La gestion d'une initialisation synchrone peut se faire en suivant deux styles diffrents prsents en programmes 24 et 26. Commenons par le changement des quations de rcurrences. Cela consiste crire

x i = ACi Dix i Init

pour l'quation concernant l'tat initial et par crire

x i = AC i D ix i Init
pour les tats non initiaux. On prend en compte une entre appele Init . Pour l'exemple qui nous intresse (Figure 12):

21

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

quations de rcurrences x1+ = x3.e4+x4.e3 + Init x2+ = (x1.e1+x2./e2)./Init x3+ = (x2.e2+x3./e4)./Init x4+ = (x1./e1+x4./e3)./Init

quations de sorties a1 = x1 a2 = x1 a3 = x3 + x4 a4 = x2

1 2 3 4 5 6 7 8 9

-- initialisation synchrone process(clk) begin if clk'event and clk='1'then -- equations de rcurrence + -- init ou -- equations de rcurrence --./init end if; end process;

Programme 24: Initialisation synchrone et quations de rcurrences

Pour tre complet nous allons donner le programme complet du graphe d'tats de la Figure 12.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 -- programme VHDL correspondant au graphe d'tats prcdent ENTITY graf1 IS PORT (I,e1,e2,e3,e4,clk : IN BIT; a1,a2,a3,a4 : OUT BIT); END graf1; ARCHITECTURE agraf1 OF graf1 IS SIGNAL x1,x2,x3,x4,x5 : BIT; BEGIN PROCESS(clk) BEGIN IF (clk'event AND clk='1') THEN x1 <= (x3 AND e4) OR (x4 AND e3) OR I; x2 <= (x1 AND e1 AND NOT I) OR (x2 AND NOT e2 AND NOT I); x3 <= (x2 AND e2 AND NOT I) OR (x3 AND NOT e4 AND NOT I); x4 <= (x1 AND NOT e1 AND NOT I) OR (x4 AND NOT e3 AND NOT I); END IF; END PROCESS; a1 <= x1; a2 <= x1; a3 <= x3 OR x4; a4 <= x2; END agraf1;

Programme 25: Initialisation synchrone et quations de rcurrences de la Figure 12

Remarquez comment les quations de sorties sont programmes. Si l'on fait un codage d'tat autre que one_hot_one , il convient d'utiliser les deux techniques prcdentes suivant notre dsir d'initialiser le bit correspondant un ou zro. Toute initialisation un se fera par l'ajout de + init (OU init) l'quation de rcurrence correspondante, tandis que toute initialisation zro se fait en multipliant par le complment logique de init. Le deuxime style utilise une technique dj utilise prcdemment (Programme 21):

22

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

1 2 3 4 5 6 7 8 9 10 11

-- initialisation synchrone process(clk) begin if clk'event and clk='1'then if init ='1' then q<= "0001"; else -- ici case ou equations de -- rcurrences end if; end if; end process;

Programme 26: Initialisation synchrone et quations de rcurrences

L'initialisation tant faite "0001", c'est le bit de poids faible q(0) qui devra grer l'quation de rcurrence de l'tat initial.

Exercice 2
tatprsent Condition Un tudiant a utilis active-FSM et gnr un programme VHDL correspondant au dessin ci-dessous. Puis il a ralis un projet pour compiler et obtenu le fichier de rapport cidessous. 1) Remplir le tableau tat prsent tat futur ci-contre en choisissant un tat futur (11)2. 2) Trouver les quations de rcurrences correspondantes. 3) Comparer au fichier rapport. Pourquoi n'y a-t-il pas d'quation combinatoire de sortie ? O est la sortie ? s1s0 00 00 01 01 10 10 0X0 1X0 X00 X10 0X0 1X0

tatfutur

e0e1Init s1+s0+

X X X 11 Une croix sur une entre indique que l'on n'a pas besoin de connatre sa valeur pour en dduire l'tat futur. (SBV=State Bit Vector) Conclusion, est-ce bien le fichier correspondant ?

23

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

ds0203 //diagram ACTIONS

e0 e1 Init clock

Sreg0 s<='0 e0='1' ' etat0 etat1

e0='0'

e1='0'

Init='1'

e0='1'

s<='0'

e1='1'

etat2

s<='1'

e0='0' Figure 13: Diagramme d'volution

| | | | | | | _________________ -| |-| |-| |-| CYPRESS |-| |-| |-| ||_______________| | | | | | | |

Warp VHDL Synthesis Compiler: Copyright (C) 1991, 1992, 1993, Cypress Semiconductor

.... State variable 'sreg0' is represented by a Bit_vector(1 downto 0). State encoding (sequential) for 'sreg0' is: etat0 := b"00"; etat1 := b"01"; etat2 := b"10"; ----------------------------------------------------------------------PLD Compiler Software: PLA2JED.EXE 21/SEP/1998 [v4.02 ] 5.1 IR 14 DESIGN EQUATIONS (19:08:48) sreg0SBV_0.D = e0 * /init * /s.Q * /sreg0SBV_0.Q + /e1 * /init * /s.Q * sreg0SBV_0.Q s.D = /e0 * /init * s.Q * /sreg0SBV_0.Q + e1 * /init * /s.Q * sreg0SBV_0.Q ........ clock init e1 e0 not used not used not used not used not used not used not used not used C20V8C __________________________________________ =| 1| |24|* =| 2| |23|* =| 3| |22|* =| 4| |21|* *| 5| |20|* *| 6| |19|* *| 7| |18|* *| 8| |17|* *| 9| |16|= *|10| |15|= *|11| |14|* *|12| |13|* __________________________________________ not used not used not used not used not used not used not used not used (sreg0SBV_0) s not used Reserved

24

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

ProgrammationdeGRAFCET
La technique de programmation des GRAFCETs par quations de rcurrences et quations de sorties peut tre compltement calque sur celle des graphes d'tats. Pour simplifier, un GRAFCET est un graphe d'tats dans lequel on remplace les tats par des tapes et donc les cercle par des carrs. Une autre diffrence est qu'il peut y avoir plusieurs jetons dans un GRAFCET donc plusieurs tapes initiales, mais ces dtails (trs importants) n'ont aucunes consquences sur notre faon de faire parce qu'on choisit une technique une quation de rcurrence par tape .

1 e1 2 e2 3

Les quations de rcurrences du GRAFCET : = = = = = x3.x5.e4+x1./e1+I (x1.e1+x2./e2)./I (x2e2+x5e4x3)./I (x1e1+e3x4)./I (x4e3+x3e4x5)./I

e4 Figure 14: Un GRAFCET et ses quations de rcurrences

x1+ x2+ 4 e3 x3+ x4+ 5 x5+

25

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

TD4:ArchitecturesprogrammablesCPLDetFPGA
Nous allons nous intresser, dans ce chapitre, des notions matrielles, c'est dire aux architectures des composants programmables. Contrairement aux annes prcdentes, nous abandonnons les architectures simples GALs (appeles parfois SPLD Simple Programmable Logic Device) pour nous intresser aux architectures complexes CPLD et FPGA.

Architecturescomplexes:unpetitpassageverslesCPLDs
Un CPLD peut tre dfini comme un assemblage de SPLDs. Nous en donnons la structure ci-dessous o chaque bloc logique peut avoir la complexit d'une 22V10 (voir TPs premire anne).

Logic block Logic block Logic block Logic block

Logic block Logic block Logic block Logic block

I/O

Programmable Interconnect (PI)

I/O

ArchitectureCPLDgnrique
Figure 15: Schma de principe des CPLD

La partie d'interconnexion (PI) est un ensemble de fils que l'on peut encore reprsenter par des fils croiss pouvant ou non s'interconnecter par fusibles programmables. On vous montre sans le dtailler l'architecture d'un bloc logique en figure 16. On reconnat bien les lments constitutifs d'une PAL.

26

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Mcell Macro cells I/O cells

PI Product term array Product term distributor

Bloclogiquegnrique(LAB=LogicArrayBlock)
Figure 16: CPLD (suite)

ArchitecturescomplexeslesFPGA
On examinera dans cette partie certains aspects des FPGA mais pas l'architecture dtaille, ce composant tant bien trop complexe pour tre compltement dtaill.

1)RappelsurlesLUTs
Une table de vrit de trois entres peut tre reprsente par un nombre 8 bits que l'on convertit en hexadcimal. Soit donc la table de vrit suivante (trois entres notes e0, e1 et e2, une sortie note s) : e2 0 0 0 0 1 1 1 1 e1 0 0 1 1 0 0 1 1 e0 0 1 0 1 0 1 0 1 s 0 1 1 0 1 0 1 0 b0 b1 b2 b3 b4 b5 b6 b7 Vous pouvez synthtiser la table de vrit l'aide d'un seul nombre sur 8 bit (poids faible en haut) : - en binaire ce nombre vaut : 0b01010110 - en hexadcimal ce nombre vaut : 0x56 (not X"56" en VHDL) Aucune simplification faire ici

La valeur hexadcimale 56 (note X"56" en VHDL) est la valeur avec laquelle il faudra initialiser votre LUT avec un composant lut3. Pour 4 entres (ce qui est notre cas), on utilise une lut4 avec 4 chiffres hexadcimaux.

2)UtiliserdesLUTsenVHDL
Un exemple est donn maintenant :
1 2 3 4 5 6 library IEEE; -- transodeur binaire -> 7 segments use IEEE.STD_LOGIC_1164.ALL; library unisim; use unisim.vcomponents.all; ENTITY transcodeur IS PORT( e : in STD_LOGIC_VECTOR(3 DOWNTO 0); -- 4 entres

27

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon) 7 8 9 10 11 12 13 14 15 16 17 s : out STD_LOGIC_VECTOR(6 DOWNTO 0)); -- 7 sorties END transcodeur; ARCHITECTURE atranscodeur OF transcodeur IS BEGIN i1 : LUT4 generic map (INIT => X"EAAA") port map( I0 => e(0), I1 => e(1), I2 => e(2), I3 => e(3), O => s(0) ); .....

Cet exemple vous montre comment on cble une LUT4 en VHDL (port map) et comment on l'initialise (generic map). Le cblage de ce composant est correct mais pas son initialisation puisqu'on vous demande de la calculer plus loin. Les deux lignes library ... et use ... sont ajouter avant toute entit qui utilise une LUT en plus bien sr de "library ieee;".

3)Exercice1
Raliser le schma correspondant au "port map" de l'exemple ci-dessus dans le composant "transcodeur" (deux rectangles, un appel "transcodeur" et un appel "LUT4"). Complter ce schma avec d'ventuels pointills en montrant que sept LUTs seront ncessaires pour raliser le transcodeur complet. Raliser une table de vrit complte du dcodage demand. En dduire les 7 valeurs hexadcimales d'initialisation des LUTs. Raliser l'architecture complte de "transcodeur" en VHDL..

4)MmoireBlockRAM(BRAM)dansunFPGA
Pour viter tout changement des options de compilation pour qu'ISE infre correctement une mmoire BRAM (Block RAM) nous allons utiliser un composant faisant partie encore une fois (comme les LUTs) des librairies Xilinx. Ce composant s'appelle RAM16X8S. Lisez le tout petit extrait de sa documentation :
Unless they already exist, copy the following two statements and paste them before the entity declaration. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 Library UNISIM; use UNISIM.vcomponents.all; -- RAM16X8S: 16 x 8 posedge write distributed -Virtex-II/II-Pro -- Xilinx HDL Libraries Guide, version 10.1.2 RAM16X8S_inst : RAM16X8S generic map ( INIT_00 => X"0000", -- INIT for bit 0 of RAM INIT_01 => X"0000", -- INIT for bit 1 of RAM INIT_02 => X"0000", -- INIT for bit 2 of RAM INIT_03 => X"0000", -- INIT for bit 3 of RAM INIT_04 => X"0000", -- INIT for bit 4 of RAM INIT_05 => X"0000", -- INIT for bit 5 of RAM INIT_06 => X"0000", -- INIT for bit 6 of RAM INIT_07 => X"0000") -- INIT for bit 7 of RAM port map ( O => O, -- 8-bit RAM data output A0 => A0, -- RAM address[0] input A1 => A1, -- RAM address[1] input A2 => A2, -- RAM address[2] input A3 => A3, -- RAM address[3] input D => D, -- 8-bit RAM data input WCLK => WCLK, -- Write clock input

=> LUT RAM

28

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon) 24 25 26 27 WE => WE -- Write enable input ); -- End of RAM16X8S_inst instantiation

Ce que l'on vous demande de faire ce stade est de comprendre comment cette RAM est initialise.

5)Exercice2 1)CalculerlesvaleursprdfiniesmettredanslaRAMpourraliserunchenillardalleret retourd'uneLEDsilasortiedelammoireestsur8ledsetsicettemmoireestutilisel'aide d'uncompteurlentcommeindiquenfigurecidessous:

Travail_a_realiser

en

divfreq 22 2 sequenceur out1 h_lente Q(17) Q(22) en_rempl clk out2 open

compteur Init en clk

Init Init clk_50MHz clk

"0000000" D
'0' '0'

A3 A2 A1 A0 RAM16X8S wclk we O sortie8bits LEDs

2) crire le generic map et le port map complets de le RAM 16X8S

29

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

TD5EmbarquerunprocesseurPicoBlaze.
Descriptionmatrielle
Un schma simple vous fera comprendre ce que l'on cherche raliser.

ROM (instructions) (Bloc RAM)

WE ADDRESS[9:0] OUT[17:0]

KCPSM3
IN_PORT[7:0] INTERRUPT RESET INSTRUCTION[17:0] CLK OUT_PORT[7:0] PORT_ID[7:0] READ_STROBE WRITE_STROBE INTERRUPT_ACK ADDRESS[9:0]

Implantation standard utilisant un bloc RAM 1Kx18 pour stocker les instructions
Figure 17: Description matrielle du PicoBlaze

Vous y distinguez deux parties essentielles : une mmoire qui contient le programme excuter et un processeur appel picoBlaze avec lequel on va travailler. Le point essentiel est de remarquer qu'il n'y a que deux entres : une horloge et un reset et aucune sortie. Autrement dit, si vous ralisez ce schma en VHDL, vous ne verrez pas grand chose se passer sur votre carte FPGA ! Face ce schma vous tes susceptible de vous posez deux questions essentielles : - comment fais-je pour mettre un programme dans la mmoire ? - comment fais-je pour entrer et sortir des informations comme allumer des LEDs, lire des interrupteurs enfin toutes les choses classiques que l'on a vu jusqu'ici ?

LemodledeprogrammationduPicoBlaze
Il peut tre prsent de la manire suivante :

7 7 7 7 7 7 7 7

s0 s2 s4 s6 s8 sA sC sE

0 0 0 0 0 0 0 0
30

7 7 7 7 7 7 7 7

s1 s3 s5 s7 s9 sB sD sF

0 0 0 0 0 0 0 0

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

9 9

Pointeur de pile SP Compteur ordinal PC

0 0

Z
C : retenue (Carry) I : masque d'interruption Z : zro

La mmoire programme est organise en 1024 instructions sur 18 bits. L'adressage se fait donc sur 10 bits (210=1024). La mmoire donne est organise en 64 octets. L'adressage se fait donc sur 6 bits (26=64) Parcomparaison,lesmicroprocesseurs8bitsavaientunespaced'adressagesur16bits.Cetespace mlangeaitdonnesetprogramme.Icionaunesparation,unetellearchitectureestappeleHarvard.

Quelquesinstructions
Lesmodesd'adressage
Le PicoBlaze connat quatre modes d'adressage. Nous n'en aborderons que deux dans cette section.

Adressage registre : c'est l'adressage le plus simple, il ne peut concerner que des registres. Op-code 0 10 10 instruction oprande(s) commentaire load s0,s1 ;charger s1 dans s0

L'opration qui permet de passer de l'ensemble des instructions et oprandes l'op-code s'appelle l'assemblage. Le programme qui ralise cette opration est un assembleur. L'opration inverse s'appelle dsassemblage. Remarquez la taille de l'op-code : 18 bits. Ces 18 bits sont composs de 5 caractres hexadcimaux de 4 bits. Ils reprsentent donc 20 bits. Pour se contenter de 18 bits, le caractre le plus gauche ne peut dpasser la valeur 3.

Adressage immdiat (Immediate) : l'oprande correspondant se trouve directement dans le programme derrire le code de l'instruction et un premier oprande. Il se fait sur 8 bits. 0 00 7F 1 80 10 load s0,7F add s0,10 ;charger 127 dans s0 ;additionner 16

On peut remarquer que les nombres (deuxime oprande) sont systmatiquement en hexadcimal. Mnmonique LOAD Operande1 sX Oprande2 aaaaaaaa (8 bits) Opcode 0 0
17 16

0
15

0
14

0 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0

xxxx est le code de X sur 4 bits.

31

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Mnmonique ADD

Operande1 sX

Oprande2 aaaaaaaa (8 bits) Oprande2 aaaaaaaa (8 bits)

Opcode 0 1
17 16

0
15

0
14

1 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique ADDCY

Operande1 sX

Opcode 0 1
17 16

1
15

0
14

1 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0

sX<sX+aaaaaaaa+C(additionavecretenue) Nous avons dj abord deux modes d'adressage en section I.3.1. Nous en prsentons deux nouveaux maintenant.

Immdiat 10 bits : l'adresse est donne sur 10 bits. L'instruction JUMP utilise ce mode d'adressage parce que l'adresse fournie est une adresse absolue de programme. Operande1 aaaaaaaaaa (10 bits) Oprande2 Opcode 1 1
17 16

Mnmonique JUMP

0
15

1
14

0 0 0
13 12

a a a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0

Direct 6 bits : l'adresse de la mmoire se trouve dans le dernier octet du code de l'instruction (sur les 6 bits de poids faible). Les instructions STORE et FETCH fonctionnent avec ce mode d'adressage et permettent d'adresser 64 octets (seulement) de la mmoire. 0601F 18056 34188 FETCH s0,1F ADD s0,56 JUMP 188 ;charge le contenu de 1F dans s0 ;additionne 56 en hexadcimal ;saute l'adresse 188 ;(sur 10 bits)

A noter les opcodes sur 18 bits (5 caractres hexadcimaux). Mnmonique FETCH Operande1 sX Oprande2 aaaaaa (6 bits) Oprande2 aaaaaa (6 bits) Opcode 0 0
17 16

0
15

1
14

1 0 x
13 12

x x 0 0 a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique STORE

Operande1 sX

Opcode 1 0
17 16

1
15

1
14

1 0 x
13 12

x x 0 0 a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0

Index : l'adresse est calcule par le contenu du registre sX utilis dans l'adressage. Ce registre est mis entre parenthses dans ce cas. L'espace mmoire tant limit 64 octets, seuls les 6 bits de poids faibles sont utiliss dans ce mode d'adressage. LOAD s2,05 FETCH s0,(s1) ADD s3,s0 ADD s1,01 SUB S2,01 JUMP NZ,188 ;boucle 5 fois (s2 compteur de boucle) ;charge le contenu donn par s1 dans s0 ;additionne 5F en hexadcimal ;permet d'aller l'adresse suivante ;s2 <- s2-1 ;saute l'adresse 188 (sur 10 bits)

00205 0188 07010 18300 18101 34188

32

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Lestableaux
Lestableauxsontlesstructuresdedonnescorrespondantl'adressageindex.Contrairementce quisepasseenlangageC,ilfautgrerlammoiredestableauxvousmme.

Monpremierprogrammeenassembleur
Nous avons dj eu l'occasion de prsenter quelques champs la section 3-1. Nous allons prsenter d'autres possibilits maintenant. Regardez le programme ci-dessous :
1 2 3 4 5 CONSTANT m,10 ;commentaire ADDRESS 300 LOAD s3,m JUMP suite suite: LOAD ...

Ondistinguedansceprogrammeunetiquette,unedfinitionsymbolique,uncommentaireetla dfinitiondel'origineduprogramme.L'tiquetteestunnomsuividedeuxpoints,ici"suite:".Ladfinition symboliqueestmpourlavaleur10(enhexadcimal).L'origineduprogrammeestenadresse300 (hexadcimal);onutiliseladirectiveADDRESS.

Comparaisondesinstructions
Si vous dveloppez autour du PicoBlaze vous serez amen utiliser plusieurs assembleurs trs proches mais pas compltement similaires, celui du KCPSM3 et celui du simulateur PBlazeIDE. A noter que si vous travaillez sous Linux, vous n'aurez pas ce problme : la syntaxe est celle de KCPSM3. KCPSM3 et kpicosim addcy subcy compare store sX, (sY) fetch sX, (sY) input sX, (sY) input Sx,KK ouput sX, (sY) return returni enable interrupt disable interrupt PBlazeIDE addc subc comp store sX, sY fetch sX, sY in sX, sY in sX,$KK out sX, sY ret reti eint dint

Il existe d'autres diffrences avec les directives que nous prsentons maintenant. Fonction constante alias de registre alias de ports KCPSM3 (et kpicosim) PBlazeIDE org $3FF MAX equ $3F addr equ s2 in_port dsin $00 33 constant MAX, 3F namereg addr, s2 constant in_port, 00

positionnement de code address 3FF

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

constant out_port 10 constant bi_port, 0F

out_port dsout $10 bi_port dsio $0F

Exercice1
On dispose d'un montage qui possde un port en entre et un port en sortie comme montr en figure cidessous. Les entres sont relies des interrupteurs et les sorties un afficheur sept segments.

Micro contrleur PicoBlaze

entrees[7:0] d en q IN_PORT[7:0] OUT_PORT[7:0] PORT_ID[7:0] CLK READ_STROBE WRITE_STROBE d q en CLK sorties[7:0]

CLK

1) Soit le programme ci-dessous

1 2 3 4 5 NAMEREG s0, interrupteurs debut : INPUT interrupteurs,0 OUTPUT interrupteurs,0 JUMP debut

Quenousdonneceprogrammesisegment"a"enPORT0.B7jusqu'"g"enPORT0.B1etlepointen PORT0.B0?crireunprogrammequipermetd'affichercorrectementlesvaleursentressur4bitsen affichagehexadcimal.Onutiliseral'adressageindexpourinitialiserlesmmoiresavecdesvaleurs prcalcules(quinesontpaslesbonnesici):

1 2 3 4 1 2 3 4 5 LOAD s0,01 ; met 1 dans registre s0 STORE s0,00 ; met s0 dans la mmoire RAM l'adresse 00 LOAD s0,4F ; met 4F dans registre s0 STOREs0,01;mets0danslammoireRAMl'adresse01 boucle: ;ajouteraquisitiondenbici FETCHsortie,(nb);conversion OUTPUTsortie,0 JUMPboucle

puisuneboucleinfinie:

2)crireleprogrammeVHDLcorrespondantlapartiematrielle. Exercice 2 Le PORT de sortie est maintenant reli des LEDs. crire un programme qui fait un chenillard aller et retour sur une LED en utilisant la technique de l'exercice 1 : initialisation de mmoire puis boucle de lecture. On prendra soin de faire une triple boucle d'attente.

34

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Annexe:lesinstructionsduPicoBlaze
Instructionsdecontrle
Les instructions de contrle peuvent toutes tre conditionnelles, dpendant du positionnement ou pas des deux drapeaux du registre d'tat, savoir C et Z. Mnmonique JUMP Operande1 aaaaaaaaaa (10 bits) aaaaaaaaaa (10 bits) aaaaaaaaaa (10 bits) aaaaaaaaaa (10 bits) aaaaaaaaaa (10 bits) Operande1 aaaaaaaaaa (10 bits) aaaaaaaaaa (10 bits) aaaaaaaaaa (10 bits) aaaaaaaaaa (10 bits) aaaaaaaaaa (10 bits) Operande1 Oprande2 Oprande2 Oprande2 Opcode 1 1
17 16

0
15

1
14

0 0 0
13 12

a a a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 0 a a a a a a a a a a

JUMP Z,

1 1
17 16

0
15

1
14

0 1 0
13 12

11 10 9 8 7 6 5 4 3 2 1 0 1 a a a a a a a a a a

JUMP NZ,

1 1
17 16

0
15

1
14

0 1 0
13 12

11 10 9 8 7 6 5 4 3 2 1 0 0 a a a a a a a a a a

JUMP C,

1 1
17 16

0
15

1
14

0 1 1
13 12

11 10 9 8 7 6 5 4 3 2 1 0 1 a a a a a a a a a a

JUMP NC,

1 1
17 16

0
15

1
14

0 1 1
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique CALL

Opcode 1 1
17 16

0
15

0
14

0 0 0
13 12

a a a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 0 a a a a a a a a a a

CALL Z,

1 1
17 16

0
15

0
14

0 1 0
13 12

11 10 9 8 7 6 5 4 3 2 1 0 1 a a a a a a a a a a

CALL NZ,

1 1
17 16

0
15

0
14

0 1 0
13 12

11 10 9 8 7 6 5 4 3 2 1 0 0 a a a a a a a a a a

CALL C,

1 1
17 16

0
15

0
14

0 1 1
13 12

11 10 9 8 7 6 5 4 3 2 1 0 1 a a a a a a a a a a

CALL NC,

1 1
17 16

0
15

0
14

0 1 1
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique RETURN

Opcode 1 0
17 16

1
15

0
14

1 0 0
13 12

0 0 0 0 0 0 0 0 0 0

11 10 9 8 7 6 5 4 3 2 1 0

35

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

RETURN Z

1 0
17 16

1
15

0
14

1 1 0
13 12

0 0 0 0 0 0 0 0 0 0

11 10 9 8 7 6 5 4 3 2 1 0 1 0 0 0 0 0 0 0 0 0 0

RETURN NZ

1 0
17 16

1
15

0
14

1 1 0
13 12

11 10 9 8 7 6 5 4 3 2 1 0 0 0 0 0 0 0 0 0 0 0 0

RETURN C

1 0
17 16

1
15

0
14

1 1 1
13 12

11 10 9 8 7 6 5 4 3 2 1 0 1 0 0 0 0 0 0 0 0 0 0

RETURN NC

1 0
17 16

1
15

0
14

1 1 1
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Instructionsdemmorisations
64 octets de RAM sont accessibles ces instructions soit en adressage direct, soit en adressage index. FETCH va chercher les donnes tandis-que STORE les stocke. Mnmonique FETCH Operande1 sX Oprande2 aaaaaa (6 bits) (sY) (6 bits) Oprande2 aaaaaa (6 bits) (sY) (6 bits) Opcode 0 0
17 16

0
15

1
14

1 0 x
13 12

x x 0 0 a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

FETCH

sX

0 0
17 16

0
15

1
14

1 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique STORE

Operande1 sX

Opcode 1 0
17 16

1
15

1
14

1 0 x
13 12

x x 0 0 a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

STORE

sX

1 0
17 16

1
15

1
14

1 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Instructionsarithmtiques
Mnmonique ADD Operande1 sX Oprande2 aaaaaaaa (8 bits) sY Opcode 0 1
17 16

0
15

0
14

1 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

ADD

sX

0 1
17 16

0
15

0
14

1 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

ADDCY additionne les deux oprandes avec le drapeau de retenue C.

Mnmonique ADDCY Operande1 sX Oprande2 aaaaaaaa (8 bits) Opcode 0 1
17 16

1
15

0
14

1 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0

36

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

ADDCY

sX

sY

0 1
17 16

1
15

0
14

1 1 x
13 12

x x y y

y y 0 0 0 0

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique SUB

Operande1 sX

Oprande2 aaaaaaaa (8 bits) sY

Opcode 0 1
17 16

1
15

1
14

0 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

SUB

sX

0 1
17 16

1
15

1
14

0 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique SUBCY

Operande1 sX

Oprande2 aaaaaaaa (8 bits) sY

Opcode 0 1
17 16

1
15

1
14

1 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

SUBCY

sX

0 1
17 16

1
15

1
14

1 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

L'instruction COMPARE ralise une soustraction mais, contrairement l'instruction SUB, le rsultat n'est pas mis jour. Seuls les bits du regitre d'tat sont positionns. Mnmonique COMPARE Operande1 sX Oprande2 aaaaaaaa (8 bits) sY Opcode 0 1
17 16

0
15

1
14

0 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

COMPARE

sX

0 1
17 16

0
15

1
14

0 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Instructionslogiques
Mnmonique LOAD Operande1 sX Oprande2 aaaaaaaa (8 bits) sY Opcode 0 0
17 16

0
15

0
14

0 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

LOAD

sX

0 0
17 16

0
15

0
14

0 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique AND

Operande1 sX

Oprande2 aaaaaaaa (8 bits) sY

Opcode 0 0
17 16

1
15

0
14

1 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

AND

sX

0 0
17 16

1
15

0
14

1 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

37

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Mnmonique OR

Operande1 sX

Oprande2 aaaaaaaa (8 bits) sY

Opcode 0 0
17 16

1
15

1
14

0 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

OR

sX

0 0
17 16

1
15

1
14

0 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique XOR

Operande1 sX

Oprande2 aaaaaaaa (8 bits) sY

Opcode 0 0
17 16

1
15

1
14

1 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

XOR

sX

0 0
17 16

1
15

1
14

1 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

L'instruction de test fait un ET logique entre deux oprandes mais, contrairement l'instruction AND, le rsultat final n'est pas mis jour. Seuls les bits d'tat sont mis jour.
Mnmonique TEST Operande1 sX Oprande2 aaaaaaaa (8 bits) sY Opcode 0 1
17 16

0
15

0
14

1 0 x
13 12

x x a a a a a a a a

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

TEST

sX

0 1
17 16

0
15

0
14

1 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Instructionsd'entressorties
Mnmonique INPUT Operande1 sX Oprande2 pppppppp (8 bits) (sY) Opcode 0 0
17 16

0
15

1
14

0 0 x
13 12

x x p p p p p p p p

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

INPUT

sX

0 0
17 16

0
15

1
14

0 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Mnmonique OUTPUT

Operande1 sX

Oprande2 pppppppp (8 bits) (sY)

Opcode 1 0
17 16

1
15

1
14

0 0 x
13 12

x x p p p p p p p p

11 10 9 8 7 6 5 4 3 2 1 0 x x x y y y y 0 0 0 0

OUTPUT

sX

1 0
17 16

1
15

1
14

0 1 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

Instructionsd'interruptions
Les instructions qui permettent d'autoriser ou non les interruptions sont :
38

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Mnmonique ENABLE

Operande1
INTERRUPT

Oprande2

Opcode 1 1
17 16

1
15

1
14

0 0 0
13 12

0 0 0 0 0 0 0 0 0 1

11 10 9 8 7 6 5 4 3 2 1 0 0 0 0 0 0 0 0 0 0 0 0

DISABLE

INTERRUPT

1 1
17 16

1
15

1
14

0 0 0
13 12

11 10 9 8 7 6 5 4 3 2 1 0

L'instruction RETURNI doit tre utilise chaque fin d'interruption. Elle fonctionne comme RETURN sauf qu'elle restore les bits de retenue et de dtection de zro du registre d'tat.
Mnmonique RETURNI Operande1 ENABLE Oprande2 Opcode 1 1
17 16

1
15

0
14

0 0 0
13 12

0 0 0 0 0 0 0 0 0 1

11 10 9 8 7 6 5 4 3 2 1 0 0 0 0 0 0 0 0 0 0 0 0

RETURNI

DISABLE

1 1
17 16

1
15

0
14

0 0 0
13 12

11 10 9 8 7 6 5 4 3 2 1

Intructionsdedcalages
Mnmonique SR0 Operande1 sX Oprande2 Opcode 1 0
17 16

0
15

0
14

0 0 x
13 12

x x 0 0 0 0 1 1 1 0

11 10 9 8 7 6 5 4 3 2 1 0 x x x 0 0 0 0 1 1 1 1

SR1

sX

1 0
17 16

0
15

0
14

0 0 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0 x x x 0 0 0 0 1 0 1 0

SRX

sX

1 0
17 16

0
15

0
14

0 0 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0 x x x 0 0 0 0 1 0 0 0

SRA

sX

1 0
17 16

0
15

0
14

0 0 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0 x x x 0 0 0 0 1 1 0 0

RR

sX

1 0
17 16

0
15

0
14

0 0 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

39

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

sX SR0 sX '0' sX SR1 sX '1' sX SRX sX sX SRA sX sX RR sX

Mnmonique SL0 Operande1 sX Oprande2 Opcode 1 0
17 16

carry

carry

carry

carry

carry

0
15

0
14

0 0 x
13 12

x x 0 0 0 0 0 1 1 0

11 10 9 8 7 6 5 4 3 2 1 0 x x x 0 0 0 0 0 1 1 1

SL1

sX

1 0
17 16

0
15

0
14

0 0 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0 x x x 0 0 0 0 0 0 1 0

SLX

sX

1 0
17 16

0
15

0
14

0 0 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0 x x x 0 0 0 0 0 0 0 0

SLA

sX

1 0
17 16

0
15

0
14

0 0 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0 x x x 0 0 0 0 0 1 0 0

RL

sX

1 0
17 16

0
15

0
14

0 0 x
13 12

11 10 9 8 7 6 5 4 3 2 1 0

40

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

AncienTD4VHDLetmachinestatsalgorithmiques
Tout ce qui a t trait jusqu' maintenant fait partie du niveau de spcification RTL (Register Transfer Level). Le niveau d'abstraction abord maintenant est appel ESL (Electronic System level) Quand la fonction synthtiser devient complexe, la synthse doit tre dcompose en deux parties : un chemin de donnes et une machine squentielle destine ordonnancer ce chemin de donnes. En automatisme le chemin de donnes est plutt appel partie oprative. On utilisera cette terminologie parfois. La synthse correspondante ncessite alors des raisonnements spcifiques : cette dcomposition demande une exprience d'autant plus grande que les parties utilises se dcomposent elles-mme en sous-parties... Disons pour simplifier que le niveau simple correspond ce que l'on fait en schma logique traditionnel : utiliser des composants simples existants. C'est ce niveau qui va nous intresser maintenant. Dans ce chapitre nous n'aborderons que superficiellement le sujet, avec des exemples. Terminologie : - organigramme de programmation : http://fr.wikipedia.org/wiki/Organigramme_de_programmation - algorigrammes : reprsentation d'un algorithme http://troumad.developpez.com/C/algorigrammes/

Utilisationsdecompteurs(commechemindedonnes)
Le compteur de passages est un exemple utilisant des compteurs squencs. Il s'agit de compter des vnements si on a d'abord le capteur gauche puis le capteur droit activs et de dcompter si le capteur droit est activ avant le capteur gauche. En logique traditionnelle, la partie oprative est compos par deux compteurs 74190 et le squenceur par une machine tats. Le squenceur peut tre ralis avec des composants programmables simples (SPLD). Donnons-en un schma de principe :
passage1 //diagramACTIONS Droite Gauche clk Init

Sreg0 Init='1'

Droite='0'andGauche='0'

DU H H

7447 74190
Rippleclock

7447 74190

S1

Droite='1' S2 Gauche='0'
Gauche=' 0'

DU<='0' H<='0' Gauche='1' S3 DU<='0' H<='0' Droite='0' Droite='0'

DU

DOWN/UP

DOWN/UP

PARTIEOPERATIVE

DU<='1' H<='0'

Gauche='1' S4 DU<='1' H<='1' Gauche='1'

Droite='1' S5

DU<='0' H<='1'

Droite='1' Figure 18: Compteur de passages

Cet exemple n'est pas conforme aux rgles d'assemblage du squentiel. En effet l'horloge H de la partie oprative est ralise par les actions du squenceur et donc par du combinatoire ce qui est interdit 41

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

lorsqu'on veut faire une synthse fiable. Nous avons eu l'occasion de raliser cet ensemble soit avec un PAL et deux 74190, soit dans un seul composant de type FPGA en utilisant un modle VHDL du 74190 et pour ces deux montages on obtient un ala de fonctionnement. Nous le prsentons donc ici seul titre d'exemple, qui a l'avantage d'tre simple comprendre. Nous allons donc nous intresser au respect des rgles d'assemblage du squentiel et modifier en consquence l'exemple ci-dessus du compteur de passages.

Miseenconformitducompteurdepassages
Le principe de base est de changer la partie chemin de donnes (les compteurs). On lui ajoute une entre en_tick de validation synchrone. Le fonctionnement des compteurs est alors le mme qu'un 74190 tant que en_tick=1 tandis que le compteur reste fig si en_tick=0. La partie squenceur est alors charge de raliser les deux signaux UD et en_tick mais pas l'horloge. L'horloge sera commune au squenceur et au chemin de donnes, mais pour un bon fonctionnement on s'arrangera pour que ces deux parties soient sensibles un front diffrent : par exemple front montant pour le squenceur et front descendant pour le chemin de donnes. C'est une bonne chose lorsqu'il s'agit de faire la sparation entre le squenceur et le chemin de donne de considrer que le premier fonctionne sur un type de front d'horloge (par exemple montant) et le deuxime sur le front complment (par exemple descendant).

Application
Exercice1 Modifier le chemin de donnes ci-dessus pour qu'il utilise la mme horloge que la partie squenceur. Donner le schma global correspondant en montrant qu'il faudra ajouter deux tats la machine d'tats du squenceur (que se passe-t-il si l'on reste dans S4 ?). Exercice 2 La gestion de l'cran VGA dj prsent en figure 5 comporte une horloge asynchrone pour le compteur vertical de 0 519. Cette horloge provient d'une comparaison c'est dire d'un circuit combinatoire ce qui ne respecte pas la rgle de base de l'assemblage du squentiel (pas d'horloge provenant de combinatoire). Comment modifier le montage pour avoir un montage compltement synchrone (mme horloge pour les deux compteurs ? Remarque : la faon de procder de l'exercice original fonctionne correctement en fait car le combinatoire n'est pas pur mais synchronis sur front descendant. Cela reste cependant une technique non recommande.

Utilisationderegistres(commechemindedonnes)
Nous nous trouvons dans la situation suivante : nous disposons de plusieurs registres qui forment ce que l'on appellera notre chemin des donnes, et nous dsirons synthtiser un circuit qui les utilise. Ce circuit peut tre combinatoire ou squentiel. Nous allons apprhender cela avec un exemple de calcul de PGCD. Son calcul est ralis l'aide de l'algorithme d'Euclide. Cet algorithme peut tre dcrit de manire rcursive de la faon suivante : a et b sont les deux valeurs dont on cherche le PGCD (avec a > b) si b = 0 alors le PGCD est a autrement on recherche le PGCD de b et du reste de la division de a par b.

LesFSMD(FiniteStateMachinewithDatapath)
Nous avons eu l'occasion de prsenter les automates finis (ou machines tats finis ou finite state machine FSM). Nous allons gnraliser avec les FSMD (Finite State Machine with Data path. La terminologie franaise associe est assez varie :

Automates Finis avec chemin de Donnes (AFD) machines registres 42

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

machines algorithmiques ou automates algorithmiques

Au del de la terminologie, ce qui nous intresse est un moyen de dcrire le fonctionnement de ces machines. Nous avons appris spcifier les automates finis l'aide des graphes d'tats (ou parfois des graphes d'volutions) nous allons prsenter maintenant notre manire de spcifier les machines registres. Cela peut se faire avec des organigrammes dans lesquels on a la possibilit de dcrire des transferts ou des oprations entre registres (appels parfois organigramme fonctionnel). Revenons sur notre exemple de calcul du PGCD. Il peut tre dcrit par l'organigramme :

initialisation A<- nb1 B<- nb2

B=0?

oui non

termin

T <- A rem B

A <- B

B <- T
Figure 19: Organigramme fonctionnel du calcul du PGCD

On suppose dans cet organigramme que l'on sait raliser l'opration T reoit A rem B, c'est dire le reste de la division de A par B. Prenons par exemple A=nb1=8 et B=nb2=6. B tant diffrent de 0, T <- 2 puis A<-6 et B<-2 B tant diffrent de 0 ,T <- 0 puis A <-2 et B <- 0 c'est fini et le rsultat est dans A soit 2. Tout cela est bien gentil, mais cela ncessite un composant capable de calculer le reste de la division. Si, comme on va le supposer par la suite, ce n'est pas le cas, il nous faut raliser en plus cette opration. Cela se fait simplement avec une suite de soustractions jusqu' obtenir un nombre plus petit que le diviseur. Il nous faut donc modifier l'organigramme en consquence (voir figure 20)

43

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

initialisation A <- nb1 B <- nb2

B=0?

oui non

termin T <- T - B non

T <- A

T<B? oui

A <- B

B <- T
Figure 20: Organigramme fonctionnel du calcul du PGCD (avec calcul explicite du reste)

Une fois vrifi le fonctionnement de notre algorithme, il nous reste le matrialiser. La partie chemin de donnes sera responsable de tous les transferts de registres et les calculs combinatoires (en gnral). Pour notre exemple, nous avons trois registres (A, B et T), quatre transferts de registres (T <A, T <- A-B, A <- B et B <- T), un calcul d'une diffrence (A-B) et deux tests B=0? et T<B?. Voil donc tout ce que doit tre capable de faire la partie chemin de donnes.

Lapartiechemindedonnes
La partie chemin de donnes est prsente maintenant : Partie chemin de donnes
e_load TrA TrD ArB BrT clk

Explications
Tous les rectangles reprsentent des

ArB B TrA BrT

Beq0 registres 8 bits, il y en a donc trois : A,B et B=0? TinfB

T TrD D

T<B?

Figure 21: Chemin de donnes pour calcul PGCD

T. Le trapze reprsente un soustracteur 8 bits ralisant la diffrence D=T-B (et non D=B-T !). C'est donc une partie combinatoire. Les deux grands cercles reprsentent aussi des parties combinatoires destines raliser des comparaisons. Les actions possibles sur cette partie oprative sont reprsentes par des "boutons" : cercles avec croix. Elles ne reprsentent que des transferts de registre.

Appuyez sur le bouton ArB et le registre A reoit le contenu du registre B. On peut donc lire ArB : A reoit B. Il en est de mme pour les trois autres boutons. Nous allons prsenter maintenant le programme VHDL ralisant cette partie. Commenons par l'entit :
1 2 library IEEE; use IEEE.std_logic_1164.all;

44

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon) 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 use IEEE.std_logic_arith.all; use IEEE.STD_LOGIC_UNSIGNED.all; entity chemin_donnees is port( ArB: in STD_LOGIC; BrT: in STD_LOGIC; TrA: in STD_LOGIC; TrD: in STD_LOGIC; e_load: in STD_LOGIC; e_A: in STD_LOGIC_VECTOR(7 DOWNTO 0); e_B: in STD_LOGIC_VECTOR(7 DOWNTO 0); s_A: out STD_LOGIC_VECTOR(7 DOWNTO 0); s_B: out STD_LOGIC_VECTOR(7 DOWNTO 0); s_T: out STD_LOGIC_VECTOR(7 DOWNTO 0); Beq0: out STD_LOGIC; TinfB: out STD_LOGIC; clk: in STD_LOGIC); end chemin_donnees;

Programme 27: Entit du chemin de donnes pour calcul du PGCD

Le lecteur perspicace aura remarqu la prsence de e_A et e_B qui ne sont pas dessins dans le schma figure 21. Ces deux entres sont destines mettre initialement des valeurs dans les deux registres A et B. Intressons-nous maintenant l'architecture o l'on retrouve un process par registre et un process par partie combinatoire :
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 27 28 29 30 31 32 33 34 35 architecture chemin_donnees_arch of chemin_donnees is -- declaration des registres signal regA,regB,regT : STD_LOGIC_VECTOR(7 DOWNTO 0); begin -- gestion des registres reg_A:process(clk)begin if clk'event and clk='0' then if ArB='1' then regA <= regB; elsif e_load='1' then regA <= e_A; else regA <= regA; end if; end if; end process; reg_B:process(clk)begin if clk'event and clk='0' then if BrT='1' then regB <= regT; elsif e_load='1' then regB <= e_B; else regB <= regB; end if; end if; end process; reg_T:process(clk)begin if clk'event and clk='0' then if TrA='1' then regT <= regA; elsif TrD='1' then regT <= regT - regB; else regT <= regT; end if; end if;

45

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon) 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 end process; -- partie combinatoire T_inf_B:process(regT,regB)begin if regT < regB then TinfB <='1'; else TinfB <='0'; end if; end process; B_eq_0:process(regB)begin if regB = "00000000" then Beq0 <='1'; else Beq0 <='0'; end if; end process; s_A <= regA; s_B <= regB; s_T <= regT; end chemin_donnees_arch;

Programme 28: Architecture du chemin de donnes pour calcul du PGCD

Lapartiesquenceur
La machine d'tats doit raliser le squencement des oprations pour que le calcul se droule correctement. La spcification de celui-ci se fait facilement partir de l'organigramme figure 20. Donnons-la l'aide d'un diagramme d'tats :

init

s_load start

0 Beq0 Beq0 6 1 2 TinfB ArB =1 5 BrT =1 4 3 TrA =1 TinfB TrD =1

Figure 22: Diagramme d'tats du squenceur pour le calcul du PGCD (avec calcul explicite du reste)

Le calcul est termin lorsqu'on arrive dans l'tat 6. Pour simplifier on a omis le retour de l'tat 6 vers l'tat init

Exercice 3 (DS parcours AUE Nov. 2008 - extraits)

On initialise le registre A 8 et B 6. Un start nous fait passer dans l'tat 0 puis dans l'tat 1. 46

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

Complter le tableau ci-dessous l'aide du diagramme d'tats du squenceur (en figure 22) et l'aide du schma du chemin de donnes (en figure 21)
Etats du graphe

I n it 0

1 8 6 8 2

A B T TinfB Beq0

8 6

8 6

X X X X 0 0

D=T-B X X

0 0

Verslessystmesmonopuces(SoC)
Si l'on dsire aller plus loin dans l'intgration de systmes dans un FPGA, il faut commencer penser aux microprocesseurs et aux micro contrleurs. Nous allons commencer par une architecture qui comporte un jeu d'instructions rduit (quatre instructions) mais trs bien pens.

tudeduminiprocesseurembarqu"MCPU"
Tim Boescke, cpldcpu@opencores.org a publi en 2001-2004 un miniprocesseur de quatre instructions (http://opencores.org/project,mcpu) destin tenir dans un CPLD. Les instructions sont les suivantes : Mnmonique NOR ADD STA JCC Opcode 00AAAAAA 01AAAAAA 10AAAAAA 11DDDDDD Description Accu = Accu NOR mem[AAAAAA] Accu = Accu + mem[AAAAAA] + maj retenue mam[AAAAAA] = Accumulateur positionne PC DDDDDD quand retenue =0 + clear carry

L'astuce de cette architecture est qu'il est possible de dfinir par dessus ces instructions des macros instructions de manire assez subtile : Macro CLR LDA mem NOT JMP dst JCS dst SUB mem MOV src,dest Assembleur NOR allone NOR allone,ADD mem NOR zero JCC dst, JCC dst JCC *+2, JCC dst NOR zero,ADD mem, ADD one NOR allone , ADD src , STA dest Vous disposez ce point de 11 instructions (4 instructions d'origine + 7 macro), ce qui est suffisant pour un calcul de PGCD. 47 Description Accu = 0 (allone doit contenir0xFF) Charge la memoire dans l'accumulateur inverse le contenu de l'accumulateur (zero contient 0x00 Saut inconditionnel dest Saut si retenue Soustrait mem de l'accu (one contient 0x01) dplacement de la mmoire src vers dest

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

TransformernotreFSMDenprogramme
Il est toujours possible de transformer un FSMD ou un diagramme d'volution tel que celui de la figure 22 en un ensemble d'instructions. Il faudra ensuite imaginer une architecture capable de raliser un tel programme. Puisque notre architecture existe il nous faut tre imaginatif et adapter les instructions. Pour notre exemple de PGCD cela peut se faire avec un programme du style :
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 27 28 USE "cpu3.inc" start: LDA allone ADD b JCC NotBeq0 JMP end NotBeq0: MOV a,t ; t <- A rem: NOR b ADD one ;Akku = - b ADD a ;Akku = a - b ;Carry set when akku >= 0 STA t NOT ;Acc = -t ADD b ;Acc = b-t JCS rem MOV b,a ;a <- b MOV t,b ;b <- t JMP start end: JMP end a: DCB (126) b: DCB (124) t: DCB (0)

Programme 29: Calcul du PGCD sur MCPU

Ce programme est facile comprendre pour qui a un peu d'exprience car il reprend la technique utilise dans le squenceur (j'ai modifi le programme original de Tim Boescke pour cela).

Transformernotreprogrammeen...
Quand on a l'habitude de faire fonctionner des processeurs on sait qu'il suffit de compiler un programme en fichier hex qu'un programmateur permettra d'envoyer une EPROM. Mais ici, comment et o va finir notre programme ? En gnral on dispose d'un convertisseur qui permet de transformer notre fichier hex en VHDL. Ce VHDL finira dans des blocs logiques ou dans de la RAM (il y en a dans tout FPGA moderne) ; c'est le style du programme VHDL qui dfinira si l'on utilise des blocs logiques ou de la RAM.

Exercice5
Le programme VHDL de description original de Tim Boescke pour dcrire son architecture est tellement simple que nous le donnons maintenant compltement :
29 30 31 32 33 34 35 36 37 38 library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; entity CPU8BIT2 is port ( data: inout adress: oe: out we: out rst: in std_logic_vector(7 downto 0); out std_logic_vector(5 downto 0); std_logic; std_logic; -- Asynchronous memory interface std_logic;

48

MCENSL1 IUT de Troyes (Serge Moutou et Gilles Millon)

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 clk: end; architecture CPU_ARCH of CPU8BIT2 is signal akku: std_logic_vector(8 downto 0); -- akku(8) is carry ! signal adreg: std_logic_vector(5 downto 0); signal pc: std_logic_vector(5 downto 0); signal states: std_logic_vector(2 downto 0); begin process(clk,rst) begin if (rst = '0') then adreg <= (others => '0');-- start execution at memory location 0 states <= "000"; akku <= (others => '0'); pc <= (others => '0'); elsif rising_edge(clk) then -- PC / Adress path if (states = "000") then pc <= adreg + 1; adreg <= data(5 downto 0); else adreg <= pc; end if; -- ALU / Data Path case states is when "010" => akku <= ("0" & akku(7 downto 0)) + ("0" & data); -- add when "011" => akku(7 downto 0) <= akku(7 downto 0) nor data; -- nor when "101" => akku(8) <= '0';-- branch not taken, clear carry when others => null; -- instr. fetch, jcc taken (000), sta (001) end case; -- State machine if (states /= "000") then states <= "000"; -- fetch next opcode elsif (data(7 downto 6) = "11" and akku(8)='1') then states <= "101"; -branch not taken else states <= "0" & not data(7 downto 6);-- execute instruction end if; end if; end process; -- output adress <= adreg; data <= "ZZZZZZZZ" when states /= "001" else akku(7 downto 0); oe <= '1' when (clk='1' or states = "001" or rst='0' or states = "101") else '0'; -- no memory access during reset and we <= '1' when (clk='1' or states /= "001" or rst='0') else '0'; -state "101" (branch not taken) end CPU_ARCH; in std_logic);

Dcomposercettearchitectureenchemindedonnesetsquenceur,d'aborddemanire schmatique,puisenprogrammeVHDL.

49