École Polytechnique de Montréal Page 1/12 Département de Génie Informatique Et Génie Logiciel

INF3500 : Conception et réalisation de systèmes numériques
Examen final
15 août 2007, 09h30-12h00
salle M-2110
Durée: 2h30.
Pondération: 40%.
Documentation: Toute permise.
Calculatrice: Programmable permise.
Directives particulières: Ordinateurs interdits, répondre à toutes les questions, la valeur de chaque ques-
tion est indiquée.
Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute supposi-
tion que vous faites.
École Polytechnique de Montréal page 1/12 Département de génie informatique et génie logiciel
INF3500 – examen final – 15 août 2007
Question 1. (8 points)
Faites la conception d’un circuit numérique combinatoire qui accepte en entrée un nombre non-signé ex-
primé avec 8 bits ainsi qu’un facteur exprimé avec 4 bits. La sortie doit être un produit de 12 bits du nom-
bre et de son facteur. Utilisez uniquement les opérations d’addition, soustraction et décalage. Votre circuit
doit être purement combinatoire, il ne doit pas inclure d’éléments à mémoire.
a. Donnez un diagramme de votre circuit.
Solution :
b. Donnez sa description en VHDL.

Solution :
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
entity finalMultiplicateur is
port (
nombre : in unsigned(7 downto 0);
facteur : in unsigned(3 downto 0);
produit : out unsigned(11 downto 0)
);
end finalMultiplicateur;
architecture arch of finalMultiplicateur is

signal add0, add1, add2, add3 : unsigned(11 downto 0);
begin
add0 <= "0000" & nombre when facteur(0) = '1' else (others => '0');
add1 <= "000" & nombre & "0" when facteur(1) = '1' else (others => '0');
produit <= (add3 + add2) + (add1 + add0);
end arch;
L’histogramme d’une image représente la distribution des intensités de ses pixels. Pour une image enco-
dée en tons de gris sur 8 bits, l’histogramme comporte 256 valeurs correspondant aux intensités 0 (noir) à
255 (blanc). Chaque valeur indique combien de pixels dans l’image ont cette intensité.
Faites la conception d’un processeur qui calcule l’histogramme des intensités d’une image. L’image est
composée d’une matrice carrée de 1024 × 1024 pixels de 8 bits chacun.
Le processeur a en entrée une horloge de 100 MHz, et les pixels arrivent à une fréquence fixe de 25 MHz,
soit un pixel tous les quatre cycles. Le processeur a en entrée un signal de synchronisation actif un cycle
d’horloge avant l’arrivée du premier pixel de l’image. Quand tous les pixels de l’image ont été reçus et
traités, le processeur doit activer un signal pour indiquer qu’il a terminé. (Un autre processeur serait res-
ponsable de lire les valeurs de l’histogramme, ce qui ne fait pas partie de la question).
a. Donnez un diagramme montrant le chemin des données du processeur. Indiquez clairement toutes les
ressources requises, leur nombre et leur largeur en bits. Indiquez clairement les signaux de contrôle.
Solution :
b. Donnez la machine à états du processeur.

Solution :
c. Donnez une description VHDL du processeur.

Solution :
library IEEE;
entity histogramme is
generic (
dimImage : integer := 2 ** 20 -- dimension de l'image en pixels
);
port (
reset, CLK, GO : in STD_LOGIC;
pixel : in unsigned(7 downto 0);
histogrammePret : out STD_LOGIC
);
end histogramme;
architecture arch of histogramme is
type type_etat is (init, lirePixel, incrementer, ecrirePixel, attendre, fini);
signal etat : type_etat;
signal compteur : integer range 0 to dimImage;
type lesRegistres_type is array(0 to 255) of integer range 0 to dimImage;
signal lesRegistres : lesRegistres_type;
signal somme : integer range 0 to dimImage;
begin
process(CLK, reset) is
begin
if (reset = '0') then
etat <= init;
elsif (rising_edge(CLK)) then
case etat is
when init =>
compteur <= 0;
lesRegistres <= (others => 0);
if GO = '1' then
etat <= lirePixel;
else
etat <= init;
end if;
when lirePixel =>
etat <= incrementer;
when incrementer =>
somme <= lesRegistres(to_integer(pixel)) + 1;
etat <= ecrirePixel;
when ecrirePixel =>
etat <= attendre;
compteur <= compteur + 1;
when attendre =>
if (compteur = dimImage) then -- a-t-on traité tous les pixels?
etat <= fini;
else
etat <= lirePixel;
end if;
when fini =>
etat <= fini;
end case;
end if;
end process;
histogrammePret <= '1' when etat = fini else '0';
end arch;
On peut déterminer le plus grand facteur commun (PGFC) entre deux nombres A et B par un algorithme
assez simple, donné ici en pseudocode :
tant que (A != B) {
si (A > B) {
A := A – B;
} sinon {
B := B – A;
}
}
retourner A;
Par exemple, pour les nombres 42 et 56, pour lesquels le PGFC est 14, on aurait la séquence suivante :
itération : 0 1 2 3
A: 42 42 28 14
B: 56 14 14 14
Faites la conception d’un processeur pour calculer le PGFC de deux nombres de 16 bits. Le processeur
doit avoir un port d’entrée unique, deux signaux de contrôle chargeA et chargeB pour charger chacun
des nombres tout à tour via le port d’entrée, un signal de contrôle GO pour démarrer les calculs, un port de
sortie de 16 bits pour le résultat, et un signal de contrôle de sortie PGFCpret qui indique que le résultat
est valide.
Solution :
b. Donnez la machine à états du processeur.

Solution :
c. Donnez une description VHDL de l’architecture du processeur correspondant à l’entité suivante.

library IEEE;
entity pgfc is
generic (
W : integer := 16
);
port (
reset, CLK : in STD_LOGIC;
entree : in unsigned(W - 1 downto 0);
go, chargeA, chargeB : in std_logic;
sortie : out unsigned(W - 1 downto 0);
PGFCpret : out std_logic
);
end pgfc;
Solution:
architecture arch of pgfc is
type type_etat is (init, calculePGFC, fini);
signal A, B : unsigned(W - 1 downto 0);
begin
begin
if (rising_edge(CLK)) then
etat <= init;
else
case etat is
when init =>
if (chargeA = '1') then
A <= entree;
end if;
if (chargeB = '1') then
B <= entree;
end if;
if (go = '1') then
etat <= calculePGFC;
else
etat <= init;
end if;
when calculePGFC =>
if (A = B) then
etat <= fini;
else
etat <= calculePGFC;
if (A > B) then
A <= A - B;
else
B <= B - A;
end if;
end if;
when fini =>
etat <= fini;
when others =>
etat <= fini;
end case;
end if;
end if;
end process;
PGFCpret <= '1' when etat = fini else '0';
sortie <= A;
end arch;
Considérez le circuit numérique suivant. Supposez que les bascules ont un temps de préparation de 1 ns,
un temps de maintien de 0.5 ns et un délai de propagation de 2 ns. Supposez qu’on peut négliger les délais
des interconnexions.
1 ns
D Q
A D Q
4 ns D
CLK 3 ns
2 ns
CLK 3 ns
D Q
1 ns
B D Q
CLK E
2 ns
CLK
D Q
C 2 ns
CLK 2 ns
CLK
déphasage d’horloge
a. Énumérez tous les chemins possibles entre paires de bascules et donnez le délai sur chacun. Supposez
qu’il n’y a pas de déphasage d’horloge.
Solution:
A/B à D : 2 + 4 + 3 = 9 ns
B/C à D : 2 + 2 + 3 = 7 ns
B à E : 2 + 1 + 2 = 5 ns
C à E : 2 + 2 + 2 = 6 ns
C à C : 2 + 2 + 2 = 6 ns
B à C : 2 + 2 + 2 = 6 ns
D à A : 2 + 1 = 3 ns
D/E à B : 2 + 2 + 3 = 7 ns
b. Identifiez le chemin critique et déterminez la fréquence maximale d’horloge. Supposez qu’il n’y a pas
de déphasage d’horloge.
Solution:
A/B à D : 2 + 4 + 3 = 9 ns
La fréquence maximale d’horloge est (9 ns + 1 ns)-1 = 100 MHz
c. Supposez que la fréquence d’opération choisie est de 50 MHz. Considérez uniquement le chemin de la
bascule D vers la bascule A via l’inverseur. Quelle sont les valeurs positives acceptables du déphasage
d’horloge pour ce chemin?
Solution:
La période correspondante à 50 MHz est 20 ns.

Après un front montant de l’horloge, la sortie de la bascule D devient stable 2 ns plus tard. L’inverseur
retarde ce signal de 1 ns.
Si on considère le temps de préparation, alors il faut T > td + tcomb + tsu – tcs, donc tcs > 2 + 1 + 1 – 20,
donc tcs > -16 ns ou > 4 ns.
Si on considère le temps de maintien, alors il faut td + tcomb – tcs > th, donc tcs < td + tcomb – th, donc
tcs < 2 + 1 – 0.5 ns ou 2.5 ns.
Donc pour ce chemin le déphasage d’horloge doit être entre 0 et 2.5 ns, ou bien entre 4 ns et 20 ns. Il ne
peut pas être entre 2.5 et 4 ns.
a. Considérez le système d’équations logiques suivant :

P = ABCD + B 'D'+ A C D + EF '
G
Q = BC + AB '
+C 'D
Considérez le circuit montré à la page suivante, qui représente une portion d’un réseau prédiffusé pro-
grammable (FPGA) général. En utilisant ce circuit, montrez comment implémenter ce système
d’équations. Indiquez clairement la position de chaque port, le contenu des tables de correspondance
(Look-Up Table – LUT) et le routage des différents signaux.
b. Considérez l’extrait de code VHDL suivant. Donnez son équivalent en matériel à l’aide d’un schéma de
portes logiques.
library ieee;
use ieee.std_logic_1164.all;
entity monModule is
port (
A : in std_logic;
B : in std_logic;
C : in std_logic;
F : out std_logic;
G : out std_logic;
H : out std_logic
);
end monModule;
architecture arch of monModule is

begin
F <= not(A and (B xor not(C)));
G <= '0' when (A = '1' or B /= C) else '1';
with A select H <= B when '0', C when others;
end arch;
École Polytechnique de Montréal
G4 G4
YQ YQ
G3 D Q G3 DQ
Table de Table de
correspondance correspondance
G2 CL G2 CL
G G
S0 K S0 K
16 X 1 16 X 1
G! G!
Y Y
H H
H1 S1 H1 S1
F4 F4
XQ XQ
F3 D Q F3 DQ
Table de Table de
F2 CL F2 CL
F F
S2 K S2 K
16 X 1 16 X 1
F1 F1
X X
S3 S3
CLK CLK
page 11/12
G4 G4
YQ YQ
G3 D Q G3 DQ
Table de Table de
G2 CL G2 CL
G G
S0 K S0 K
16 X 1 16 X 1
G! G!
Département de génie informatique et génie logiciel
Y Y
H H
H1 S1 H1 S1

F4 F4
XQ XQ
F3 D Q F3 DQ
Table de Table de
F2 CL F2 CL
F F
S2 K S2 K
16 X 1 16 X 1
F1 F1
X X
S3 S3
CLK CLK
Solution:
Examen intra
18 juin 2007
Durée: 2h.
Pondération: 20%.
tion est indiquée.
Un système simple de sécurité pour un immeuble consiste en un lecteur de cartes magnétiques, d'
un cla-
vier à trois touches, de deux portes et d'
une alarme.
Un utilisateur doit entrer son code d' identification personnel en pesant sur une, deux ou trois touches du
clavier simultanément, puis glisser sa carte dans le lecteur. L' alarme est déclenchée si la carte n'est pas
reconnue, ou si un code incorrect est entré pour la carte glissée. La porte correspondante est débarrée si la
carte est valide et que le bon code est entré.
Le lecteur de cartes donne les codes suivants selon la carte glissée:
état signal A signal B
pas de carte glissée 0 0
carte conforme pour la porte #1 0 1
carte conforme pour la porte #2 1 1
carte non valide 1 0
Les codes d'

identification personnels acceptables sont les suivants:
porte codes valides
#1 101 et 110
#2 101 et 011
Donnez un modèle VHDL synthétisable d’un circuit combinatoire correspondant à ce système de sécurité.
INF3500 – examen intra – 18 juin 2007
Solution :
library IEEE;
use IEEE.STD_LOGIC_1164.all;
entity securite is
port(
A, B : in std_logic;
code : in std_logic_vector(2 downto 0);
porte1, porte2, alarme : out STD_LOGIC
);
end securite;
architecture arch of securite is
begin
process(A, B, code)
variable carte1 : boolean := false;
variable carte2 : boolean := false;
variable carteNV : boolean := true;
variable code1 : boolean := false;
variable code2 : boolean := false;
begin
carte1 := (A = '0' and B = '1');

carte2 := (A = '1' and B = '1');
carteNV := (A = '1' and B = '0');
code1 := (code = "101" or code = "110");

code2 := (code = "101" or code = "011");
if (carte1 and code1) then

porte1 <= '1';
else
porte1 <= '0';
end if;
if (carte2 and code2) then

porte2 <= '1';
else
porte2 <= '0';
end if;
if ( carteNV or (carte1 and not(code1)) or (carte2 and not(code2)) ) then

alarme <= '1';
else
alarme <= '0';
end if;
end process;
end arch;
Un circuit combinatoire a quatre entrées (R, S, T, U) et deux sorties (Y, Z). L’entrée RSTU représente un
chiffre de 0 à 9 encodé avec le code BCD. Les deux bits YZ représentent le reste quand RSTU est divisé
par 3. Vous pouvez supposer que seulement des entrées valides seront appliquées au système.
Donnez les équations booléennes pour les sorties Y et Z sous la forme d’une somme de produits mini-
male. (Ne pas donner de code VHDL)
Solution :
Y = S’TU’ + ST’U + RU’
Z = ST’U’ + R’S’T’U + STU
La déclaration d’entité suivante en VHDL correspond à un circuit combinatoire qui accepte en entrée un
nombre de six bits et qui a une sortie pour indiquer si le nombre est divisible par sept. Donnez une archi-
tecture pour cette entité.
library ieee;
use ieee.std_logic_1164.ALL;
use ieee.numeric_std.all;
entity multipleDeSept is
port (
I : in unsigned(5 downto 0);
F : out std_logic
);
end multipleDeSept;
Solution :
architecture arch of multipleDeSept is
begin
with to_integer(I) select
F <=
'1' when 0 | 7 | 14 | 21 | 28 | 35 | 42 | 49 | 56 | 63,
'0' when others;
end arch;
Complétez le banc d’essai VHDL suivant pour vérifier, de façon exhaustive, le circuit de la question 3. Le
banc d’essai doit indiquer, à la console seulement, pour quels cas le circuit à vérifier donne une sortie in-
correcte.
library ieee;
entity multipleDeSeptTB is
end multipleDeSeptTB;
architecture arch of multipleDeSeptTB is
component multipleDeSept
port (I : in unsigned(5 downto 0); F : out std_logic);
end component;
signal I : unsigned(5 downto 0);

signal F : std_logic;
begin
-- votre code ici
end arch;
Solution :
UUT : multipleDeSept port map (I, F);
process
constant kmax : integer := 63;
begin
for k in 0 to kmax loop
I <= to_unsigned(k, I'length);
wait for 10 ns;
assert ((k mod 7 = 0) = (F = '1'))
report "erreur pour l'entrée " & integer'image(k) severity error;
assert k < kmax
report "simulation terminée" severity failure;
end loop;
end process;
Considérez le modèle VHDL suivant. Donnez le diagramme d’états correspondant.

library IEEE;
entity controleQ5 is
port (
x : in STD_LOGIC_VECTOR(1 downto 0);
sortie : out STD_LOGIC
);
end controleQ5;
architecture arch of controleQ5 is

type type_etat is (S1, S2, S3, S4);
signal etat : type_etat := S1;
begin
begin
etat <= S1;
case etat is
when S1 =>
if x = "00" then
etat <= S3;
elsif x = "01" then

etat <= S2;
end if;
when S2 | S3 =>
if x = "10" then
etat <= S4;
elsif x = "11" then
etat <= S1;
end if;
when S4 =>
etat <= S1;
end case;
end if;
end process;
process(x, etat)
begin
case etat is
when S1 | S4 =>
sortie <= '1';
when S2 | S3 =>
if x = "10" then
sortie <= '0';
else
sortie <= '1';
end if;
end case;
end process;
end arch;
Solution :
x=autres
x=00
x=autres
sortie <= ‘1’
reset S1
x=11 S3
Sortie = 1 sortie <= ‘1’
x=01 x=11 x=10

sortie <= ‘1’ sortie <= ‘0’
S4
S2
x=10 Sortie = 1
sortie <= ‘0’
x=autres
sortie <= ‘1’
Examen final
7 décembre 2008, 13h30-16h00
Durée: 2h30.
Pondération: 40%.
Documentation: Une feuille recto-verso 8.5”×11” ou A4 manuscrite permise.
tion est indiquée.
INF3500 – examen final –7 décembre 2008
La plupart des systèmes numériques utilisent le système binaire pour les opérations arithmétiques. Cepen-
dant, lors de l’affichage pour des êtres humains, le système décimal est utilisé. Les circuits de conversion
entre les deux sont complexes et lents. La représentation décimale encodée en binaire (BCD – binary
coded decimal) a pour but de remédier à cette situation. En BCD, chaque chiffre d’un nombre peut
prendre une valeur entre 0 et 9, inclusivement, et est encodé sur quatre bits : {0000, 0001, 0010, 0011,
0100, 0101, 0110, 0111, 1000, 1001}.
Pour additionner deux chiffres BCD, on utilise un additionneur binaire à quatre bits et une retenue. Il y a
deux cas: soit que la somme est un chiffre BCD valide (0 à 9) ou bien la somme est égale ou supérieure à
10. Dans le premier cas, aucune action n’est requise. Dans le deuxième cas, il faut ajouter +6 à la somme
obtenue. La combinaison de la retenue et de la somme finale produit alors un résultat correct.
Exemple : addition 3 + 4 en BCD :
3 0011
+4 +0100
07 0|0111 somme inférieure à 10, résultat correct (retenue 0, somme 7)

7 0111
+8 +1000
15 0|1111 somme supérieure à 9, il faut ajouter +6
+0110 +6
1|0101 résultat correct, retenue de 1, somme de 5

9 1001
+8 +1000
17 1|0001 somme supérieure à 9, il faut ajouter +6
+0110 +6
1|0111 résultat correct, retenue de 1, somme de 7
a. (4 points) Donnez un diagramme d’un circuit combinatoire pour un additionneur BCD à un chiffre.
Vous pouvez utiliser des opérations logiques et arithmétiques (mais pas la division ni le modulo), la com-
paraison, des multiplexeurs, décodeurs et encodeurs, et toute autre porte logique de base. Identifiez bien
chaque bloc et donnez la largeur en bits de tous les signaux. Votre circuit doit être purement combinatoi-
re, il ne doit pas inclure d’éléments à mémoire.
b. (2 points) En utilisant des instances d’un module additionneur BCD à un chiffre développé à la partie
a., donnez un diagramme d’un circuit combinatoire pour un additionneur BCD à 8 chiffres. Vous pouvez
supposer que les additionneurs à 4 bits de votre module peuvent accepter une retenue en entrée en plus de
produire une retenue de sortie. Identifiez bien chaque bloc et donnez la largeur en bits de tous les signaux.
Votre circuit doit être purement combinatoire, il ne doit pas inclure d’éléments à mémoire.
c. (2 points) En utilisant une seule instance du module additionneur BCD à un chiffre développé à la par-
tie a., donnez un circuit séquentiel itératif pour un additionneur BCD à 8 chiffres. Vous pouvez supposer
que les additionneurs à 4 bits de votre module peuvent accepter une retenue en entrée en plus de produire
une retenue de sortie.
Solution :
a.
b.
c.
% &
% &
#$$ ($ ) * '
( (
( #$$ (
$ *
( + )( +
" #$$
,(
+ - *
+ ( . / / (
( (0 /(( *
' $ 1
#$$ ) (
! $ ( (+
*
Considérez le problème de la vérification d’un circuit combinatoire qui doit rencontrer les spécifications
de la question 1a.
Complétez le squelette de banc d’essai suivant en VHDL en incluant une génération algorithmique de
vecteurs de tests ainsi qu’une évaluation automatisée des réponses du circuit. Vous devez effectuer un test
exhaustif, et la simulation doit s’arrêter dès qu’une erreur survient ainsi que lorsque tous les vecteurs de
test ont été appliqués. Vous pouvez supposer que seulement des entrées BCD valides doivent être appli-
quées au circuit. Indiquez clairement dans quelle partie du code existant votre code doit être placé.
Dans l’entité à vérifier, les ports oper1 et oper2 sont des chiffres BCD exprimés sur quatre bits. Le
port somme est un chiffre BCD exprimé sur quatre bits, représentant la somme. Le port cout représente
la retenue, et occupe un bit unique.
library ieee;
use ieee.math_real.all;
entity addbcdTB is
end addbcdTB;
architecture tbexhaustive1 of addbcdTB is

component addbcd
port(
oper1, oper2 : in UNSIGNED(3 downto 0);
somme : out UNSIGNED(3 downto 0);
cout : out std_logic );
end component;
signal oper1, oper2, somme : UNSIGNED(3 downto 0);
signal cout : std_logic;
-- vous pouvez ajouter du code ici si nécessaire ...
begin
UUT : addbcd port map (oper1, oper2, somme, cout);
end tbexhaustive1;
Solution :
architecture tbexhaustive1 of addbcdTB is
component addbcd
port(
oper1, oper2 : in UNSIGNED(3 downto 0);
somme : out UNSIGNED(3 downto 0);
cout : out std_logic );
end component;
signal oper1, oper2, somme : UNSIGNED(3 downto 0);

signal cout : std_logic;
begin
UUT : addbcd port map (oper1, oper2, somme, cout);
process
variable lasomme : integer := -1;
begin
for k1 in 0 to 9 loop
for k2 in 0 to 9 loop
oper1 <= to_unsigned(k1, 4);
oper2 <= to_unsigned(k2, 4);
wait for 10 ns;
if cout = '1' then

lasomme := 10 + to_integer(somme);
else
lasomme := to_integer(somme);
end if;
assert lasomme = k1 + k2 report "erreur!" severity failure;
end loop;
end loop;
report "simulation terminée!" severity failure;
end process;
end tbexhaustive1;
Un processeur spécialisé doit être conçu pour calculer la moyenne arithmétique d’une plage de cellules
dans une mémoire RAM de 1024 cellules de 8 bits chacune. Les données en mémoire sont exprimées en
complément à deux. La moyenne arithmétique est donnée par la somme des valeurs des cellules, divisée
par le nombre de cellules. Avant d’effectuer le calcul, le processeur doit d’abord recevoir, sur deux ports
distincts et simultanément, l’adresse de la première cellule de la plage ainsi que le logarithme en base 2
du nombre de cellules entrant dans le calcul de la moyenne. Le nombre de cellules est donc toujours une
puissance positive de 2. Le chargement est effectué quand un signal de contrôle spécial ‘go’ est activé,
puis le processeur débute ses opérations.
Le processeur doit effectuer le calcul, puis activer un signal spécial lorsque le résultat est appliqué à son
port de sortie. Il doit aussi activer un signal d’erreur spécial à la sortie si la cellule de départ et le nombre
de cellules spécifiés sont tels que la plage spécifiée dépasse la dernière cellule de la mémoire. La
moyenne doit être exprimée sur 8 bits.
a. (4 points) Donnez un diagramme montrant le chemin des données de ce processeur. Identifiez bien
chaque bloc et indiquez la largeur en bits de tous les ports et de tous les signaux.
b. (4 points) Spécifiez l’unité de contrôle de ce processeur par un diagramme d’états. Identifiez bien les
états et les conditions pour les transitions. Identifiez les signaux de contrôle appliqués au chemin des don-
nées.
Solution :
a.
- ( -
1 ( -9 5
: ; 5 < 1* 6
1
4 6 6 !
1 1
1 77
234
6 1
51
6 (
1
b.
Considérez le code VHDL suivant pour un arbitre de bus. L’arbitre permet à trois processeurs de partager
un bus unique. Quand un processeur veut avoir accès au bus, il active un des trois signaux de contrôle r
(pour « requête »). Pour informer un des processeurs qu’il peut se servir du bus, l’arbitre l’informe grâce à
l’un des trois signaux de contrôle g (pour « go »). Quand le processeur correspondant a terminé du bus, il
en informe l’arbitre de bus en désactivant son signal de requête r.
Donnez un diagramme d’états illustrant le fonctionnement de ce module. Identifiez clairement chaque
état, les transitions entre les états, et les conditions de transition entre les états.
-- code tiré de S. Brown & Z. Vranesic,

-- Fundamentals of Digital Logic, McGraw-Hill, 2005.
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY arbiter IS
PORT ( Clock, Resetn : IN STD_LOGIC ;
r : IN STD_LOGIC_VECTOR(1 TO 3) ;
g : OUT STD_LOGIC_VECTOR(1 TO 3) ) ;
END arbiter ;
ARCHITECTURE Behavior OF arbiter IS

TYPE State_type IS (Idle, gnt1, gnt2, gnt3) ;
SIGNAL y : State_type ;
BEGIN
PROCESS ( Resetn, Clock )
BEGIN
IF Resetn = '0' THEN y <= Idle ;
ELSIF (Clock'EVENT AND Clock = '1') THEN
CASE y IS
WHEN Idle =>
IF r(1) = '1' THEN y <= gnt1 ;
ELSIF r(2) = '1' THEN y <= gnt2 ;
ELSIF r(3) = '1' THEN y <= gnt3 ;
ELSE y <= Idle ;
END IF ;
WHEN gnt1 =>
IF r(1) = '1' THEN y <= gnt1 ;
ELSE y <= Idle ;
END IF ;
WHEN gnt2 =>
IF r(2) = '1' THEN y <= gnt2 ;
ELSE y <= Idle ;
END IF ;
WHEN gnt3 =>
IF r(3) = '1' THEN y <= gnt3 ;
ELSE y <= Idle ;
END IF ;
END CASE ;
END IF ;
END PROCESS ;
g(1) <= '1' WHEN y = gnt1 ELSE '0' ;
g(2) <= '1' WHEN y = gnt2 ELSE '0' ;
g(3) <= '1' WHEN y = gnt3 ELSE '0' ;
END Behavior ;
Solution :
(tiré de S. Brown & Z. Vranesic, Fundamentals of Digital Logic, McGraw-Hill, 2005.)
Questions à développement.
a. (1 point) Énumérez quatre (4) éléments fondamentaux qu’on peut retrouver sur un FPGA présentement
en vente sur le marché.
b. (1 point) Expliquez, à l’aide d’un diagramme, le principe de la programmation d’un dispositif pro-
grammable EEPROM ou Flash par grille flottante.
c. (1 point) Expliquez en deux ou trois phrases chacune les étapes de synthèse, d’association (mapping),
de placement et de routage.
d. (1 point) Considérez l’énoncé suivant : « Pour un circuit numérique implémenté sur FPGA, il n’y a pas
de désavantage à utiliser le principe du pipeline au maximum, parce que les bascules sont à toutes fins
pratiques gratuites. » Dites si vous êtes en accord ou en désaccord avec cet énoncé, et expliquez en quel-
ques lignes pourquoi.
Solution :
a. Pour 0.25 point chacun:
blocs de logique programmable (CLB), blocs d’entrées-sorties (IOB), réseau d’interconnexions, circuits
de routage rapide des retenues, blocs de mémoire intégrée, blocs de fonctions arithmétiques avancées
(multiplicateurs, multiplicateurs-accumulateurs), microprocesseurs fixes, circuits de génération et de dis-
tribution d’horloge
Pour 0.125 point chacun :
LUT, flip-flop, multiplexeur
b. Dans son état normal, la grille flottante est déchargée et le transistor fonctionne normalement, c' est-à-
dire qu’une tension appliquée à la grille du transistor induit un canal et permet au courant de passer entre
la source et le drain du transistor. Pour ‘programmer’ la cellule, on place une tension élevée sur la grille
de contrôle et le drain du transistor, comme montré dans la figure. Comme un courant élevé circule dans
le canal, des électrons sont attirés par la grille de contrôle et vont s’emmagasiner sur la grille flottante. La
tension négative de la grille flottante est alors suffisante pour neutraliser toute tension normale appliquée
à la grille de contrôle, et le transistor ne conduit plus. Le transistor peut conserver cet état programmé
plusieurs années.
Pour ‘déprogrammer’ le transistor, on applique une tension élevée uniquement au drain de celui-ci, com-
me montré ici. La tension est suffisante pour attirer les électrons emmagasinés sur la grille flottante, à
travers de l’isolant. Le transistor fonctionne alors normalement.
c. Le synthétiseur produit une description du circuit en termes d’éléments logiques simples à partir d’une
description dans un langage de description matérielle comme VHDL. Le synthétiseur indique aussi les
interconnexions entre ces composantes. Le produit du synthétiseur est communément appelé « liste des
interconnexions (netlist)».
mapping) consiste
Le processus d’association (mapping te à associer des composantes de base à des blocs ou des
groupes de blocs logiques du FPGA. Par exemple, un groupe de portes logiques peut être combiné en une
seule table de conversion d’un bloc logique.
Le placement consiste à disposer les composantes du circuit en rangées et en colonnes. Ce placement est
souvent effectué de façon à respecter certaines contraintes de temps et/ou d’espace imposées par
l’utilisateur.
Le routage consiste à choisir les chemins suivis par les fils d’interconnexions entre les composantes
co du
circuit. Cette étape est soumise aussi à des contraintes, habituellement de temps.
d. Plutôt en accord. Une fois qu’on a choisi un FPGA en particulier, il n’y a pas de coût associé à
l’utilisation de chacune des ressources de la puce. Si le ddébit
ébit d’information doit être maximisé, alors le
fait de pipeliner autant que possible devrait être encouragé, en utilisant toutes les bascules disponibles.
Cependant, ajouter un grand nombre d’étages de pipeline augmente la latence du circuit, ce qui pourrait
pourr
aller à l’encontre des spécifications.
Une pile est une structure de données à laquelle on ne peut ajouter des éléments que sur le dessus, et de
laquelle on ne peut enlever des éléments que du dessus aussi. Une pile est donc une structure de la forme
DAPS: Dernier Arrivé, Premier Servi. Quand la pile est pleine, il n’est pas possible d’y rajouter un élé-
ment. Quand la pile est vide, il n’est pas possible d’y lire un élément.
Considérez la déclaration d’entité suivante en VHDL pour une pile:
library ieee;
entity pile is
generic (
N : positive := 3; -- la profondeur (le nombre d'éléments) de la pile
W : positive := 8 -- la largeur (en bits) de la pile
);
port (
clk : in std_logic;
reset : in std_logic; -- Actif haut: un '1' réinitialise la pile.
din : in std_logic_vector(W - 1 downto 0); -- Données entrant dans la pile.
dout : out std_logic_vector(W - 1 downto 0); -- Données sortant de la pile.
wr_en : in std_logic; -- Write-enable: si actif, une donnée sera lue de din et
-- placée sur la pile au prochain front montant de clk,
-- si la pile n'est pas pleine.
-- Le signal wr_en a préséance sur le signal rd_en.
rd_en : in std_logic; -- Read-enable: si actif, la donnée du dessus de la pile
-- sera retirée et placée sur dout au prochain front
-- montant de clk, si la pile n'est pas vide.
-- Quand wr_en est actif, le signal rd_en n'est pas
-- considéré.
empty : out std_logic; -- Indique que la pile est vide.
full : out std_logic -- Indique que la pile est pleine.
);
end pile;
Donnez une architecture pour cette entité qui respecte les spécifications données dans les commentaires
de la déclaration des ports.
Solution :
architecture arch of pile is
type memoire is array (0 to N - 1) of std_logic_vector(W - 1 downto 0);

signal lapile : memoire;
begin
process(clk, reset)
variable pointeurdepile : natural range 0 to N := 0;
begin
pointeurdepile := 0;
elsif (clk'event and clk = '1') then
if (wr_en = '1') then

if (pointeurdepile /= N) then
lapile(pointeurdepile) <= din;
pointeurdepile := pointeurdepile + 1;
end if;
elsif (rd_en = '1') then
if (pointeurdepile /= 0) then
pointeurdepile := pointeurdepile - 1;
dout <= lapile(pointeurdepile);
end if;
end if;
end if;
if (pointeurdepile = 0) then empty <= '1'; else empty <= '0'; end if;
if (pointeurdepile = N) then full <= '1'; else full <= '0'; end if;
end process;
end arch;
Examen intra
21 octobre 2008
Durée: 2h.
Pondération: 20%.
tion est indiquée.
INF3500 – examen intra – 21 octobre 2008
La fonction majorité accepte un certain nombre d’entrées, les inspecte, et indique si le nombre de bits en
entrée avec une valeur ‘1’ est supérieur au nombre de bits en entrée avec une valeur de ‘0’. Par exemple,
pour le vecteur d’entrée "11010", la sortie serait ‘1’. Considérez la déclaration d’entité suivante en
VHDL:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity majorite is
generic (
W : positive := 5 -- le nombre de bits d'entrée
);
port (
I : in std_logic_vector(W - 1 downto 0);
F : out std_logic
);
end majorite;
Donnez une architecture synthétisable pour cette entité. (Barème de correction : pour un maximum de 2
points sur 3, donnez une architecture synthétisable qui est valide uniquement pour W = 5. Pour un maxi-
mum de 3 points sur 3, donnez une architecture synthétisable qui est valide pour toute valeur de W.)
Solution :
architecture flotdedonnees of majorite is
-- **********************************
-- valide uniquement pour W = 5 !!!!!
-- **********************************
begin
with I select
F <= '1' when "00111" | "01011" | "01101" | "01110" |
"01111" | "10011" | "10101" | "10110" |
"10111" | "11001" | "11010" | "11011" |
"11100" | "11101" | "11110" | "11111",
'0' when others;
end flotdedonnees;
architecture comportementale of majorite is

begin
process (I)
variable compte : integer := 0;
begin
compte := 0;
for k in W - 1 downto 0 loop
if I(k) = '1' then
compte := compte + 1;
end if;
end loop;
if (compte > W / 2) then

F <= '1';
else
F <= '0';
end if;
end process;
end comportementale;
Faites la conception d’un circuit numérique combinatoire qui accepte en entrée un vecteur de 8 bits repré-
sentant un nombre positif de secondes. Votre circuit doit avoir deux sorties binaires donnant le nombre de
minutes et secondes correspondantes. Donnez un diagramme de votre circuit, ne donnez pas de code
VHDL. Indiquez la largeur des ports de sortie en bits. Vous pouvez utiliser des opérations logiques et
arithmétiques (mais pas la division ni le modulo), la comparaison, des multiplexeurs, décodeurs et enco-
deurs, et toute autre porte logique de base. Votre circuit doit être purement combinatoire, il ne doit pas
inclure d’éléments à mémoire.
Solution :
Considérez le code VHDL suivant pour un module combinatoire et son banc de test associé.
library IEEE; library IEEE;
use IEEE.STD_LOGIC_1164.all; use IEEE.STD_LOGIC_1164.all;
entity sim is entity simTB is

port ( end simTB;
entrees : in std_logic_vector(2 downto 0);
sorties : out std_logic_vector(3 downto 0) architecture arch of simTB is
);
end sim; component sim
port (
architecture arch of sim is entrees : in std_logic_vector(2 downto 0);
signal T : std_logic_vector(1 downto 0); sorties : out std_logic_vector(3 downto 0)
begin );
end component;
T(1) <= entrees(1) xor entrees(0);
sorties(3) <= entrees(2) xor T(1); signal entrees : std_logic_vector(2 downto 0);
signal sorties : std_logic_vector(3 downto 0);
process(entrees)
begin begin
T(0) <= entrees(1) xor entrees(0);
sorties(2) <= entrees(2) xor T(0); UUT : sim port map(entrees, sorties);
end process; entrees <= "111" after 0 ns,
"001" after 10 ns,
process(entrees) "011" after 20 ns,
variable T4 : std_logic; "101" after 30 ns;
begin
T4 := entrees(1) xor entrees(0); end arch;
sorties(1) <= entrees(2) xor T4;
end process;
process(entrees(0))
begin
sorties(0) <= entrees(2) xor T(0);
end process;
end arch;
Donnez la valeur des signaux sorties(3), sorties(2), sorties(1) et sorties(0) aux temps de simulation 1 ns,
11 ns, 21 ns et 31 ns.
Solution :
Considérez le diagramme d’états et la déclaration d’entité suivants. Les transitions ayant pour origine et
destination le même état ne sont pas indiquées. Donnez le modèle VHDL correspondant en décrivant une
architecture pour cette entité.
library IEEE;
entity machineetats is
port (
);
end machineetats;
Solution:
architecture arch of machineetats is
type type_etat is (S1, S2, S3);
begin
begin
etat <= S1;
case etat is
when S1 =>
if x = "00" then
etat <= S3;
elsif x = "01" then
etat <= S2;
end if;
when S2 =>
if x = "10" then
etat <= S3;
elsif x = "11" then
etat <= S1;
end if;
when S3 =>
etat <= S1;
end case;
end if;
end process;
process(etat)
begin
case etat is
when S1 | S3 =>
sortie <= '1';
when S2 =>
sortie <= '0';
end case;
end process;
end arch;
Un compteur Johnson est particulier parce que tous les ‘1’ du compte sont toujours placés en un seul
groupe qui se déplace. Par exemple, pour un compteur Johnson à quatre bits, la séquence serait : 0000,
0001, 0011, 0111, 1111, 1110, 1100, 1000, 0000, 0001, 0011, etc. On observe que le bit inséré en position
la moins significative est égal à l’inverse du bit le plus significatif.
Donnez une architecture synthétisable pour la déclaration d’entité suivante en VHDL de façon à modéli-
ser un compteur Johnson.
(Barème de correction : pour un maximum de 2 points sur 3, donnez une architecture synthétisable qui est
valide uniquement pour W = 5. Pour un maximum de 3 points sur 3, donnez une architecture synthétisa-
ble qui est valide pour toute valeur de W.)
library IEEE;
entity compteurJohnson is
generic (
W : positive := 5
);
port (
reset, clk: in std_logic;
compte : out std_logic_vector(W - 1 downto 0)
);
end compteurJohnson;
Solution
architecture arch1 of compteurJohnson is
begin
process(clk, reset)
variable c : std_logic_vector(W - 1 downto 0) := (others => 'X');
begin
if (rising_edge(clk)) then
if reset = '1' then
c := (others => '0');
else
c := c(W - 2 downto 0) & not(c(W - 1));
end if;
end if;
compte <= c;
end process;
end arch1;
a. (1 point) Donnez deux causes possibles du déphasage d’horloge dans un système numérique.
b. (1 point) Considérez le circuit suivant. Les délais des portes logiques combinatoires sont indiqués. Les
bascules ont un temps de propagation de 2 ns, un temps de préparation de 1 ns, et un temps de maintien
de 0.5 ns. Toutes les bascules sont alimentées par le même signal d’horloge. Donnez le chemin critique en
indiquant les composantes sur ce chemin, et donnez la fréquence maximale d’horloge.
c. (1 point) Un concepteur veut accélérer le circuit en plaçant un registre de pipeline sur le fil entre la
porte NON-ET et la porte NON-OU. Cette approche est-elle valide? Quel en est l’effet?
Solution :
a. charges inégales sur le réseau de distribution, longueurs inégales dans le chemin de distribution, contrô-
le d’horloge par portes logiques (clock gating)
b. Chemin critique : B-xor-net-nou-ou-F : 2+4+2+2+3+1 = 14 ns -> fmax = 71.4 MHz
c. L’approche n’est pas valide et aurait pour effet de changer la fonction du circuit. Pour accélérer le cir-
cuit par pipelinage au point mentionné, il faudrait aussi insérer une bascule supplémentaire juste après la
bascule D et juste après la bascule E.
Examen final
12 août 2008
Durée: 2h30.
Pondération: 40%.
Directives particulières: Ordinateurs interdits, répondre à toutes les questions, la valeur de
chaque question est indiquée.
Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute
supposition que vous faites.
Les deux systèmes de numération les plus populaires sont à virgule fixe et à virgule flottante. Le
système à virgule fixe correspond aux types char, short, int, et long, et le système à vir-
gule flottante correspond aux types float et double du langage C. Le système à virgule flot-
tante peut représenter une plus grande gamme de nombres avec moins de bits, mais avec moins
de précision.
Par exemple, pour la représentation d’un nombre B non signé à virgule fixe avec 11 bits b10b9b8
… b1b0 la valeur du nombre est égale à . Le plus grand nombre pouvant être repré-
senté est alors 211 – 1 = 2047. La même gamme de nombres peut être représentée approximati-
vement avec un système à virgule flottante de 7 bits seulement, avec une mantisse M de 4 bits et
un exposant E en base 2 de 3 bits. La valeur du nombre est égale à
. Dans ce système simplifié, les nombres et leurs exposants sont positifs ou nuls. Le
tableau suivant donne des exemples d’équivalences entre les deux systèmes. Il indique aussi
l’erreur d’approximation de la représentation en virgule flottante.
Représentation Représentation en virgule flottante

Nombre B
en virgule fixe Exposant E Mantisse M Erreur
(base 10)
(11 bits) (3 bits) (4 bits) (base 10)
0 00000000000 000 0000 0
1 00000000001 000 0001 0
13 00000001101 000 1101 0
49 00000110001 010 1100 1
633 01001111001 110 1001 57
2041 11111111001 111 1111 121
On observe que l’exposant correspond à l’indice du ‘1’ le plus significatif du nombre, moins 3.
S’il n’y a pas de ‘1’ aux indices 4 à 10, l’exposant est 0. On observe aussi que la mantisse est
donnée par les 4 bits à partir du ‘1’ le plus significatif, ou par les 4 bits les moins significatifs du
nombre si il n’y a pas de ‘1’ aux indices 4 à 11.
Vous devez concevoir un circuit numérique combinatoire qui accepte en entrée un nombre non
signé représenté en format virgule fixe sur 11 bits et qui retourne sa valeur en format virgule
flottante avec 4 bits pour représenter la mantisse M et 3 bits pour représenter l’exposant E en
base 2. Vous pouvez utiliser des blocs préconçus comme des multiplexeurs, décodeurs, enco-
deurs, additionneurs, décaleurs, etc. Votre circuit doit être purement combinatoire, il ne doit pas
a. Donnez un diagramme de votre circuit.
b. Donnez sa description en VHDL.

a. Solution :
(
(
(
(
( % & '
(
(
(
!
"# $
b. Solution :
library IEEE;
entity vfixeavflottante is
port (
B : in unsigned(10 downto 0);
E : out unsigned(2 downto 0);
M : out unsigned(3 downto 0)
);
end vfixeavflottante;
architecture arch1 of vfixeavflottante is

begin
process(B)
begin
E <= to_unsigned(0, E'length);
M <= B(3 downto 0);
for k in B'length - 1 downto 3 loop
if B(k) = '1' then
E <= to_unsigned(k - 3, E'length);
M <= B(k downto k - 3);
exit;
end if;
end loop;
end process;
end arch1;
Concevez un processeur qui effectue la traduction d’adresses dans un routeur. La traduction

d’adresses consiste à faire correspondre une adresse IP d’un intranet à une adresse IP publique
visible sur le web. Un des buts de cette technique de sécurité est de rendre le réseau intranet invi-
sible du web et donc moins susceptible aux attaques de pirates informatiques. Pour ce faire, des
tables de correspondances sont implémentées telles que :
- table_adresse_ip_interne : liste des adresses internes valides
- table_adresse_ip_externe : liste des adresses externes associées correspondantes.
La Figure 1 illustre un cas de correspondance entre plusieurs adresses. L’adresse IP 0 (0.0.0.0)

n’est allouée à aucune machine.
Figure 1. Exemple de correspondance entre deux tables.
En bref, le circuit fonctionnera comme suit :

- Remise à zéro des tables : le circuit doit être capable d’initialiser les tables en mettant
toutes leurs cases à 0.
- Mise à jour des tables : le circuit doit pouvoir mettre à jour les cases une par une selon des
requêtes entrantes. Une requête de mise à jour précisera les cases à mettre à jour dans les
deux tables. Pour cela, l’adresse des cases sera transmise ainsi que les nouvelles valeurs à
écrire dans celles-ci.
- Recherche d’adresses : le circuit doit être capable de répondre à des requêtes de recherche.
Il recevra une adresse IP qui peut être une adresse interne ou externe et il devra retourner
l’adresse externe ou interne correspondante. Si aucune correspondance n’est trouvée alors
une erreur sera émise.
- Une mise à jour ne peut pas s’effectuer en même temps qu’une requête de recherche.
La Figure 2 précise les interfaces du circuit NAT.

entity nat is
generic (tab_size : integer := 10);
port (
rst_n : in std_logic;
clk : in std_logic;
maj_req : in std_logic;
maj_adr : in std_logic_vector(tab_size-1 downto 0);
maj_ip_prive : in std_logic_vector(31 downto 0);
maj_ip_publique : in std_logic_vector(31 downto 0);
recherche_req : in std_logic;
ip_type : in std_logic;
ip_recherche : in std_logic_vector(31 downto 0);
recherche_resp : out std_logic;
erreur: out std_logic;
ip_trouve : out std_logic_vector(31 downto 0)
);
end nat;
Figure 2. Déclaration de l’entité nat
Les interfaces se décrivent comme suit :

rst_n Le circuit est réinitialisé lorsque ce signal est égal à ‘0’. Toutes les
cases des tables seront mises à 0.
clk L’horloge du circuit.
maj_req Le signal d’activation d’écriture.
maj_adr L’adresse mémoire dans laquelle les adresses IP transmises interne
et externe seront écrites.
maj_ip_prive L’adresse IP privée (interne) à écrire.
maj_ip_publique L’adresse IP publique (externe) à écrire.
recherche_req Ce signal est activé lorsqu’une requête de recherche est transmise.
ip_type Lorsque ce port est égal à ‘1’ alors c’est l’adresse IP privée qui est
transmise et le circuit doit fournir l’adresse IP publique correspon-
dante. Lorsque ce port est égal à ‘0’ alors c’est l’adresse IP publique
qui est transmise et le circuit doit fournir l’adresse IP privée corres-
pondante.
ip_recherche L’adresse IP dont on recherche la correspondance.
recherche_resp Ce signal est activé par le circuit lorsque la réponse de recherche est
prête.
erreur Ce signal est activé lorsque l’adresse transmise en requête n’est pas
contenue dans une des tables.
ip_trouve L’adresse de sortie correspondante à l’adresse IP recherchée.
Vous devez :
a) donner le diagramme du chemin de données du NAT (5 points).
b) donner le diagramme de la machine à états de l’unité de contrôle du NAT. Identifier clai-
rement les états ainsi que les valeurs des signaux de contrôle en fonction des états de la
machine (5 points).
c) écrire le code VHDL du chemin des données seulement (4 points).
a. Solution
(Note: On pourrait considérer que le compteur et la logique qui lui est associée ne font pas partie
du chemin des données mais plutôt de l’unité de contrôle.)
b. Solution
c. solution (toute l’entité, chemin des données et machine à états)
library ieee;
entity nat is
generic (tab_size : integer := 10);
port (rst_n : in std_logic;

clk : in std_logic;
maj_req : in std_logic;
maj_adr : in std_logic_vector(tab_size-1 downto 0);
maj_ip_prive : in std_logic_vector(31 downto 0);
maj_ip_publique : in std_logic_vector(31 downto 0);
recherche_req : in std_logic;
ip_type : in std_logic;
ip_recherche : in std_logic_vector(31 downto 0);
recherche_resp : out std_logic;
erreur: out std_logic;
ip_trouve : out std_logic_vector(31 downto 0)
);
end nat;
architecture beh of nat is

signal operation : std_logic;
signal compteur_sel : integer range 0 to 2;
signal compteur : integer range tab_size-1 downto 0;
type tab_type is array (tab_size-1 downto 0) of std_logic_vector(31 downto 0);
signal tab_ip_interne : tab_type;
signal tab_ip_externe : tab_type;
signal tabs_LectureEcritureN : std_logic;
signal tab_addr : std_logic_vector(tab_size-1 downto 0);
signal ip_lu : std_logic_vector(31 downto 0);
type etat_type is (ATTENTE, INIT, MAJ, LECTURE, VERIFIER,
INCREMENTER, RETOURNERERREUR, RETOURNERIP);
signal etat : etat_type;
begin -- beh
unite_controle : process (clk, rst_n)
begin -- process unite_controle

-- activities triggered by asynchronous reset (active low)
if rst_n = '0' then
etat <= INIT;
-- activities triggered by rising edge of clock
elsif clk'event and clk = '1' then
-- Mise a jour de la FSM
case etat is
when ATTENTE =>
if maj_req = '1' then
etat <= MAJ;
elsif recherche_req = '1' then
etat <= LECTURE;
end if;
when INIT =>
etat <= ATTENTE;
when MAJ =>
etat <= ATTENTE;
when LECTURE =>
etat <= VERIFIER;
when VERIFIER =>
if ip_lu = ip_recherche then
etat <= RETOURNERIP;
elsif compteur = tab_size-1 then
etat <= RETOURNERERREUR;
else
etat <= INCREMENTER;
end if;
when INCREMENTER =>
etat <= LECTURE;
when RETOURNERERREUR =>
etat <= ATTENTE;
when RETOURNERIP =>
etat <= ATTENTE;
when others =>
etat <= ATTENTE;
end case;
end if;
end process unite_controle;
-- chemin de donnees
-- gestion des memoires
process (clk, rst_n)
begin -- process
if rst_n = '0' then
for i in 0 to tab_size-1 loop
tab_ip_interne(i) <= (others => '0');
tab_ip_externe(i) <= (others => '0');
end loop; -- i
compteur <= 0;

if tabs_LectureEcritureN = '0' then
tab_ip_interne(to_integer(unsigned(tab_addr))) <= maj_ip_prive;
tab_ip_externe(to_integer(unsigned(tab_addr))) <= maj_ip_publique;
end if;
if compteur_sel = 0 then -- init
compteur <= 0;
elsif compteur_sel = 1 then -- incrementer
compteur <= compteur + 1;
else
compteur <= compteur;
end if;
end if;
end process;
-- lecture et multiplexage de l'IP lu selon le type de l'adresse a lire

ip_lu <= tab_ip_interne(to_integer(unsigned(tab_addr))) when ip_type = '0'
else tab_ip_externe(to_integer(unsigned(tab_addr)));
ip_trouve <= ip_lu;
-- mise a jour des signaux de controle et de sortie selon l'etat courant

recherche_resp <= '1' when etat = RETOURNERIP or etat = RETOURNERERREUR else '0';
erreur <= '1' when etat = RETOURNERERREUR else '0';
tabs_LectureEcritureN <= '0' when etat = MAJ else '1';
compteur_sel <= 0 when etat = ATTENTE else 1 when etat = INCREMENTER else 2;
tab_addr <= maj_adr when tabs_LectureEcritureN = '0' else
std_logic_vector(to_unsigned(compteur, tab_addr'length));
end beh;
Considérez le processeur à usage général décrit au chapitre 8 des notes de cours. Nous désirons
ajouter une nouvelle instruction :
Rk MEM[adresse] + Rk
Cette instruction lit dans la mémoire de données le contenu de la case MEM[adresse], et le met
sur le signal A qui entre dans l’UAL. Pendant ce temps, le contenu du registre Rk est aussi lu et
mis sur le signal B qui sera aussi utilisé par l’UAL. L’UAL effectuera l’addition puis le résultat
transmis sur sa sortie F sera écrit dans le registre Rk. Donc, le résultat de l’addition sera écrit
dans le registre source.
Vous devez :
a. donner le diagramme modifié du chemin de données du processeur (2 points).
b. donner la liste et une brève description du/des signal/signaux signaux que vous rajoutez au
processeur (1 point).
c. donner l’encodage de l’instruction en conformité avec l’encodage décrit dans les notes de
cours, section 8, tableau 8.5 (1 point).
d. donner la valeur des signaux de contrôle du processeur (les anciens et les nouveaux) si
l’instruction à exécuter est R0 MEM[20] + R4. Suivez le format du tableau suivant :
lectureEcritue’
choixCharge
choixSource
opération
instruction
choixA
choixB
charge
….
….
Rk MEM[adresse] + Rk
a. solution
)*+
)*+
b. solution : Le signal UAL_choixA a été rajouté. Il sera actif lorsque l’instruction sera décodée,
sinon par défaut il sera égal à ‘0’.
c. solution
d. solution
lectureEcritue’
UAL_choixA
choixCharge
choixSource
opération
instruction
choixA
choixB
charge
Rk <– MEM[] + Rk 0 0 1 - 4 0 1 1
Soit le circuit suivant.
Figure 3. Circuit numérique.
En sachant que les contraintes de temps sont les suivantes :

- Les bascules ont un temps de préparation de 1 ns, un temps de maintien de 1 ns et un délai de
propagation de 2 ns.
- Les portes logiques ET et OU ont un délai de propagation de 2 ns
- Les portes logiques XOR ont un délai de propagation de 3 ns.
Les bascules du circuit ont un reset asynchrone.
Vous devez :
a) En tenant compte des délais, compléter le chronogramme donné à la page suivante afin
de fournir les variations de la sortie OUT1 jusqu’au temps t = 150 ns (Remettre la page
du chronogramme avec votre cahier d’examen) (4 points).
b) Identifier le chemin critique et calculer la fréquence d’horloge maximale (4 points).
Nom: ____________________ Matricule: ___________________
Question 4 a (compléter et remettre avec votre cahier)

Solution
a.
b.
Chemin critique : A/B -> XOR -> ET -> OR -> F
Fréquence d’horloge :
T = tdA + tcombXOR + tcombET + tcombOR + tsetupF = 2 + 3 + 2 + 2 + 1 = 10 ns.
Donc, Fmax = 1/10-9 = 100 MHz.
Soit le bloc de logique programmable (CLB) suivant :

0
12 0
, #
- .
)*+
/
)*+
, #
- .
12 / 0
32( 4--
Vue simplifiée d’un CLB.
Dans ce CLB, on peut programmer 2 tables de conversion, 2 multiplexeurs et une porte logique
OU. La sortie F0 de la porte OU peut être connectée à l’entrée d’un autre CLB ou connectée aux
autres sorties du CLB : F1 et F0. Les entrées IN0 à IN9, GND et VCC peuvent être connectées à
tous les éléments du CLB. L’entrée GND permet de propager la valeur logique ‘0’ et l’entrée
VCC la valeur ‘1’. Les sorties des tables de conversion et celles des multiplexeurs peuvent être
connectées à une des sorties F1 et F2.
Utilisez ce patron de CLB pour concevoir une porte ET à 8 entrées illustrée par la figure sui-
vante. Montrez les connexions internes et externes entres les différents éléments des CLB et
entre les entrées/sorties des CLB que vous utiliserez. Précisez la fonction logique que chacune
des tables de conversion effectuera.
Porte ET à 8 entrées.
Solution :
Solution proposée par Xilinx pour le Virtex II Pro. Plusieurs solutions sont possibles.
Examen intra
18 juin 2008
Durée: 2h.
Pondération: 20%.
tion est indiquée.
Un encodeur simplifié de code Morse prend en entrée un vecteur de 7 bits (InCar), encode ce dernier et
fournit le code correspondant sur trois ports de sortie (OCar1, OCar2, OCar3) qui sont chacun des vec-
teurs de 2 bits. Ce module encode seulement les caractères ascii : A, D, G, I, K et M, comme l’indique le
tableau suivant.
Table d’encodage
Caractère Code ICardec OCar1 OCar2 OCar3
Morse
“A” 65 “00” “01” “11”
“D” 69 “01” “00” “00”
“G” 72 “01” “01” “00”
“I” 73 “00” “00” “11”
“K” 75 “01” “00” “01”
“M” 76 “01” “01” “11”
autres N/A autres “11” “11” “11”
En sachant, que les caractères du code sont encodés comme suit :

- : “00”
- : “01”
- Rien : “11”
Donnez la description VHDL de l’encodeur de code Morse (librairies, entité et architecture).
Solution
library ieee;
entity code_morse is
port (ICar : in std_logic_vector(6 downto 0);

OCar1 : out std_logic_vector(1 downto 0);
OCar2 : out std_logic_vector(1 downto 0);
OCar3 : out std_logic_vector(1 downto 0));
end code_morse;
architecture dataflow of code_morse is

type array_t is array (natural range<>) of std_logic_vector(5 downto 0);
constant codes : array_t := ("000111", "010000", "010100", "000011", "010001", "010111",
"111111");
begin -- dataflow
process (ICar)
variable k : integer;
begin -- process
case to_integer(unsigned(ICar)) is
when 65 => k := 0; -- '
A'
when 69 => k := 1; -- '
D'
when 72 => k := 2; -- '
G'
when 73 => k := 3; -- '
I'
when 75 => k := 4; -- '
K'
when 76 => k := 5; -- ' M'
when others => k := 6;
end case;
OCar1 <= codes(k)(5 downto 4);

OCar2<= codes(k)(3 downto 2);
OCar3 <= codes(k)(1 downto 0);
end process;
end dataflow;
Écrivez le code VHDL de l’architecture d’un filtre d’image dont l’entité « filtre_pixel » est présentée ci-
après. Ce module reçoit en entrée le pixel à filtrer qui est un nombre non-signé et dont la taille est para-
métrée. L’opération de filtrage s’effectue comme suit :
- si la valeur du pixel entrant est inférieure à Seuil1 alors pixel_out = Seuil1;
- si la valeur du pixel entrant est supérieure à Seuil2 alors pixel_out = Seuil2;
- sinon par défaut pixel_out = pixel_in.
INF3500 – examen intra – 1er novembre 2007
En sachant que Seuil1 et Seuil2 sont des paramètres du module qui ont une valeur par défaut égale à 32 et
192 respectivement.
library ieee;
entity filtre_pixel is
generic(
N : positive := 8; -- Nombre de bits des pixels
Seuil1 : positive := 32; -- le Seuil inférieur
Seuil2 : positive := 192 -- le Seuil supérieur
);
port (
pixel_in : in unsigned(N-1 downto 0); -- Pixel entrant
pixel_out : out unsigned(N-1 downto 0) -- Pixel calcule
);
end filtre_pixel;
Solution
entity filtre_pixel is
generic(
N : positive := 8;
Seuil1 : positive := 32;
Seuil2 : positive := 192
);
port (
pixel_in : in unsigned(N-1 downto 0);
pixel_out : out unsigned(N-1 downto 0)
);
end filtre_pixel;
architecture behavior of filtre_pixel is
begin -- behavior
process (pixel_in)
begin -- process
if pixel_in < Seuil1 then
pixel_out <= to_unsigned(Seuil1, N);
elsif pixel_in > Seuil2 then
pixel_out <= to_unsigned(Seuil2, N);
else
pixel_out <= pixel_in;
end if;
end process;
end behavior;
Écrivez le code VHDL d’un banc d’essai qui testera le filtre d’images décrit à la question 2. Les pixels
entrants du filtre à tester auront une taille de 4 bits et les seuils : Seuil1 et Seuil2 seront égaux à 2 et 13
respectivement.
Le banc d’essai doit ouvrir un fichier d’images qui se nomme « image_in.pgm » qui a le format suivant :
Format_image
nb_lignes nb_colonnes
pixel_max_value
Pixel0 Pixel1 Pixel2 ……. Pixel( nb_lignes x nb_colonnes-1 ))
L’exemple suivant montre le contenu d’un fichier d’image dont le format est P5. Cette image comporte 3
lignes et trois colonnes en sachant que la valeur maximale des pixels devrait être égale à 15.
P5
33
15
3 2 0 3 12 14 17 8 9(la ligne de pixels)
Les pixels sortant seront écrits dans un fichier de sortie qui se nommera « image_out.pgm ». Le format du
fichier de sortie sera le même que celui du fichier d’entrée. Donc il faudra copier l’entête de l’image en-
trante dans le fichier de sortie avant d’écrire les pixels sortant.
Le nombre de pixels à traiter devra être égal à la taille de l’image (nb_lignes * nb_colonnes). Les pixels
sont écrits sur une ligne unique dans le fichier d’image.
Le banc d’essai transmettra un nouveau pixel au module à tester à chaque 10 ns.
Durant la lecture de l’image entrante, si un pixel lu a une valeur supérieure à la valeur maximale précisée
dans le fichier (pixel_max_value), le banc d’essai devra afficher un message d’erreur et arrêter la simula-
tion.
Solution
library ieee;
use std.textio.all;
entity filtre_pixel_tb is
generic (Nbits : integer := 4);
end filtre_pixel_tb;
architecture beh of filtre_pixel_tb is

signal pixel_in1 : unsigned(3 downto 0);
signal pixel_out1 : unsigned(3 downto 0);
constant filename_in : string := "image_in.pgm";
constant filename_out : string := "image_out.pgm";

file vecteurs : text open read_mode is filename_in;
file resultats : text open write_mode is filename_out;
component filtre_pixel
generic(
N : positive;
Seuil1 : positive := 32;
Seuil2 : positive := 192
);
port (
pixel_in : in unsigned(N-1 downto 0);
pixel_out : out unsigned(N-1 downto 0)
);
end component;
begin -- beh
UUT : filtre_pixel
generic map (N => Nbits, Seuil1 => 2, Seuil2 => 13)
port map (pixel_in => pixel_in1, pixel_out =>pixel_out1);
process
-- purpose:
variable tampon_in : line; -- pointeur vers un objet de type string
variable tampon_out : line; -- pointeur vers un objet de type string
variable n : integer;
variable c : character;
variable nb_lignes : integer;
variable nb_colonnes : integer;
variable pixel_max_value : integer;
variable nb_pixels_lus : integer := 0;
begin -- process
-- lecture premiere ligne du fichier
if not endfile(vecteurs) then
readline(vecteurs, tampon_in);
writeline(resultats, tampon_in);
end if;
-- lecture seconde ligne

write(tampon_out, tampon_in.all);
writeline(resultats, tampon_out);
read(tampon_in, nb_lignes);
read(tampon_in, c);
read(tampon_in, nb_colonnes);
end if;
-- lecture troisieme ligne

write(tampon_out, tampon_in.all);
read(tampon_in, pixel_max_value);
end if;
-- lecture des pixels

end if;
while nb_pixels_lus < (nb_lignes * nb_colonnes) loop
read(tampon_in, n);
read(tampon_in, c);
-- verifier que la valuer du pixel lu est inferieure a pixel_max_value
assert n < pixel_max_value
report "ERREUR : un pixel dont la valeur depasse la valeur maximale a ete lu
- ARRET DE LA SIMULATION" severity failure;
-- envoi du pixel vers le UUT

pixel_in1 <= to_unsigned(n, Nbits);
nb_pixels_lus := nb_pixels_lus + 1;
wait for 10 ns;
-- ecriture du resultat dans le fichier de sortie

write(tampon_out, integer' image(to_integer(pixel_out1)) & string'
(" "));
end loop;
end if;
deallocate(tampon_in); -- relâcher la mémoire du tampon

deallocate(tampon_out); -- relâcher la mémoire du tampon
end process;
end beh;
Concevez un gestionnaire de boîte vocale. L’entité du gestionnaire est décrite comme suit :
entity gest_boite_vocale is
port (
reset_n : in std_logic; -- le reset du circuit
clk : in std_logic; -- l'horloge
tonalite : in std_logic; -- la tonalite
fin_lecture_accueil : in std_logic; -- il est actif lorsque le message d'accueil est complete
boite_pleine : in std_logic; -- il signale que la memoire de la boite vocale est pleine
lecture_accueil : out std_logic; -- il active le debut de la lecture du message d'accueil
enregistrement : out std_logic -- il active le debut du commencement d'un enregistrement
);
end gest_boite_vocale;
Le gestionnaire fonctionne comme suit :

- Lorsque la tonalité est basse cela signifie qu’il n’y a aucun appel entrant. Dès que la tonalité est
haute cela signifie qu’un appel entrant est actif.
- Si la tonalité reste haute pendant trois coups d’horloge consécutifs, alors le gestionnaire devra ac-
tiver le port « lecture_accueil » pendant jusqu’à ce que le port « find_lecture_accueil » soit mis à
‘1’.
- Si avant les trois coups d’horloge la tonalité descend à ‘0’ alors le gestionnaire se remettra en
mode d’attente d’un nouvel appel.
- Après avoir activé la lecture du message d’accueil, le gestionnaire attendra que le port entrant
fin_lecture_accueil soit activé (‘1’).
- Puis, le gestionnaire activera le port « enregistrement » à ‘1’.
- Il attendra que le port « tonalite » soit désactivé (‘0’) ou que le port « boite_pleine » soit activé
pour arrêter l’enregistrement (mettre le port « enregistrement » à ‘0’) et se remettre en mode at-
tente d’un nouvel appel.
- Lorsque le circuit est réinitialisé (reset_n = ‘0’), toutes les sorties doivent être mises à 0et la ma-
chine à états du circuit doit être réinitialisée.
a) Donnez le diagramme d’états du gestionnaire de boîte vocale

b) Complétez le code VHDL de la machine à état correspondante en donnant l’architecture associée
à l’entité décrite ci-avant.
Solution
a) Diagramme d’états
Tonalite = ‘0’
Tonalite = ‘1’
Attente Appel entrant
Tonalite = ‘0’ OU
boite_pleine = ‘1’
Compteur = 2
Enregis- Fin_lecture_accueil = ‘1’ Attente fin Activation
lecture lecture
trement
accueil accueil
b) Code VHDL de l’architecture

architecture beh of gest_boite_vocale is
type state_t is (ATTENTE, APPEL_ENTRANT, ACTIVATION_LECTURE_MACCUEIL,

ATTENTE_FIN_LECTURE_MACCUEIL, ENREGISTREMENT_MESSAGE);
signal etat_courant : state_t := ATTENTE;
signal etat_prochain : state_t := ATTENTE;
signal compteur_courant : integer range 2 downto 0;
signal reset_compteur : std_logic;
begin -- beh
-- mise a jour de l'
etat courant ou des signaux registres
process (clk, reset_n)
begin -- process
if reset_n = ' 0'then
etat_courant <= ATTENTE;
elsif clk'event and clk = '1'then
etat_courant <= etat_prochain;
end if;
end process;

etat courant ou des signaux registres
begin -- process
if reset_n = ' 0'then

compteur_courant <= 0;
elsif clk'event and clk = '1'then
if reset_compteur = ' 0'and compteur_courant < 2 then
compteur_courant <= compteur_courant + 1;
else
compteur_courant <= 0;
end if;
end if;
end process;

etat prochain
process (etat_courant, tonalite, boite_pleine, compteur_courant)
begin -- process
etat_prochain <= etat_courant;
reset_compteur <= ' 0';
case etat_courant is
when ATTENTE =>
if tonalite = '
1'then
etat_prochain <= APPEL_ENTRANT;
reset_compteur <= ' 1';
end if;
when APPEL_ENTRANT =>
if compteur_courant = 2 then
etat_prochain <= ACTIVATION_LECTURE_MACCUEIL;
elsif tonalite = '
0'then
etat_prochain <= ATTENTE;
end if;
when ACTIVATION_LECTURE_MACCUEIL =>
etat_prochain <= ATTENTE_FIN_LECTURE_MACCUEIL;
when ATTENTE_FIN_LECTURE_MACCUEIL =>
if fin_lecture_accueil = '1'then
etat_prochain <= ENREGISTREMENT_MESSAGE;
end if;
when ENREGISTREMENT_MESSAGE =>
if boite_pleine = '1'or tonalite = '
0'then
etat_prochain <= ATTENTE;
end if;
end case;
end process;
-- -- mise a jour des sorties -- MOORE

process (etat_courant)
begin -- process
when ACTIVATION_LECTURE_MACCUEIL =>
lecture_accueil <= '

1';
enregistrement <= '0'
;
when ATTENTE_FIN_LECTURE_MACCUEIL =>
0';
;
when ENREGISTREMENT_MESSAGE =>
0';
;
when others =>
0';
;
end case;
end process;
-- mise a jour des sorties -- MEALY

-- process (etat_courant, reset_n, tonalite, boite_pleine)
-- begin -- process
-- case etat_courant is
-- when ACTIVATION_LECTURE_MACCUEIL =>
-- lecture_accueil <= '1'
;
-- enregistrement <= ' 0'
;
-- when ATTENTE_FIN_LECTURE_MACCUEIL =>
;
;
-- when ENREGISTREMENT_MESSAGE =>
-- if boite_pleine = '
0'and tonalite = '
1'then
-- lecture_accueil <= ' 0' ;
-- enregistrement <= ' 1';
-- else
-- lecture_accueil <= '0';
-- end if;
-- when others =>
;
;
-- end case;
-- if reset_n = '0'then
-- lecture_accueil <= '0';
-- end if;
-- end process;
end beh;
Questionnaire
examen final
INF3500
Sigle du cours
Identification de l’étudiant(e)
Nom : Prénom :
Signature : Matricule : Groupe :
Sigle et titre du cours Groupe Trimestre

INF3500 Conception et réalisation de systèmes numériques Tous 20081
Professeur Local Téléphone
François-Raymond Boyer M-4404 5062/5193
Jour Date Durée Heures
Samedi 26 avril 2008 2h30 9h30
Documentation Calculatrice
Toute Aucune
Les cellulaires, agendas
Aucune Programmable électroniques ou téléavertisseurs
sont interdits.
Voir directives particulières Non programmable
Directives particulières
Ordinateurs interdits (une calculatrice exécutant du VHDL est un ordinateur), répondre à toutes les
questions, la valeur de chaque question est indiquée.
Total possible de 42 sur 40.
Bonne chance à tous!
Cet examen contient x4 questions sur un total de x3 pages (excluant cette page)
Important
La pondération de cet examen est de 40 %
Vous devez répondre sur : le questionnaire le cahier les deux
Vous devez remettre le questionnaire : oui non
Le plagiat, la participation au plagiat, la tentative de plagiat entraînent automatiquement l'attribution de la note F dans tous les
cours suivis par l'étudiant durant le trimestre. L'École est libre d'imposer toute autre sanction jugée opportune, y compris
l'exclusion.
Tous les codes VHDL font :
Question 1. [17 points]

L’opération d’exponentiation entière est très utile en cryptographie. Nous voulons trouver c = ab mod n, où a, b et
n sont des entiers positifs. Ces nombres sont de grande taille (>512 bits) pour avoir un système de cryptage assez
sécuritaire. Voici l’algorithme d’exponentiation utilisé :
! "
# # " "
!$"
%% // décaler d’un bit vers la gauche (laissant tomber le bit qu’on vient de tester)
&
Idée de l’algorithme (pas nécessaire de le comprendre pour répondre à la question) :
Nous utilisons simplement le fait que ab = (a a)b/2 (l’exposant reste entier s’il était pair), et a b = a b − 1 a (permet de changer
un exposant impair en exposant pair). Appliquer directement ces règles ferait un algorithme récursif, mais en commençant
par le bit de poids fort il devient itératif.
Comme première étape de la conception d’un circuit faisant cette opération, vous considérez n = 2' où ' est le
nombre de bits des entiers $, et . Ceci vous permettra de faire des tests sans que l’équipe qui s’occupe de la
multiplication modulaire ait terminé leur circuit. L’opération « mod n » revient donc à prendre les bits de poids
faible du résultat (()*+,) - . " en VHDL permet de changer la taille en bits d’un ).
Le processeur dédié à l’exponentiation aura en entrée les signaux , $, et (en plus des
signaux habituels et /), et en sortie les signaux et # . Les signaux $ et chargent
la valeur dans $ et , respectivement, lorsque le circuit est en attente. Le circuit commence à calculer
lorsque , et lorsqu’il a terminé et que la valeur du (la valeur de ) est valide, il indique # .
Pour des considérations de taille, un seul multiplieur doit être utilisé dans le circuit (si l’opérateur de
multiplication « * » est utilisé plusieurs fois dans le code VHDL, le synthétiseur les combinera uniquement si les
deux mêmes signaux sont multipliés ensemble aux différents endroits).
a. [5 pts] Donnez un diagramme montrant le chemin des données du processeur. Indiquez clairement toutes les
b. [5 pts] Donnez la machine à états du processeur. Identifiez bien chaque état, les actions à prendre dans chaque
état, et les conditions pour les transitions entre les états.
c. [7 pts] Donnez une description de votre processeur en VHDL, en vous basant sur le début de code suivant.
0
'1 " -- nombre de bits des opérandes
. 23. 1
1 '4 5 6"
$. 1
1 '4 5 6"
# 1 "
0
# 0
$. . 1 '4 5 6"
INF3500 – Examen intra – 14 mars 2008
Considérez le problème de la vérification d’un circuit combinatoire qui doit rencontrer les spécifications de la
question 1.
Complétez le squelette de banc d’essai suivant en VHDL en incluant une génération algorithmique de vecteurs de
tests ainsi qu’une évaluation automatisée des réponses du circuit. Indiquez clairement dans quelle partie du code
existant votre code doit être placé. Rappel : les opérateurs !! et sont définis sur les , et 5 et
5 # peuvent être utilisés en série sans contraintes si le n’a pas de liste de sensibilité.
0 7
' 1 +8 7)9 )( 1 :" -- un petit nombre, pour faire les tests initiaux
0 7
7 $( ; +7) 7< () # 0 7
0
' 1 +8 7)9 )("
. 23. 1
1 '4 5 6"
$. 1
1 '4 5 6"
# 1 "
. 23. 1 1 =6=
1 < 8 *+9 8 )> '4 5 6"
$. 1 1 =6=
1 < 8 *+9 8 )> '4 5 6"
# 1
1 1 6
<<7 1 0 ' ? '"

. 23. . . $. . .# "
- $. . $ 0 1 6 @ !! ' 4 1 6
7 $( ; +7) 7< ()
...
Considérez le processeur à usage général décrit dans les notes de cours, sections 8.6 à 8.8 inclusivement. Nous
voulons supporter une plus grande mémoire d’instructions ainsi que la possibilité de faire des sous-routines. Pour
ce faire, les branchements seront relatifs (les 8 bits d’adresse spécifiés dans l’instruction seront considérés comme
une valeur signée disant la position où aller relativement à l’instruction présentement pointée), et deux nouveaux
types de branchements seront ajoutés : le JAL (jump and link) qui copie le pointeur d’instruction dans R15 avant
d’effectuer le saut, et le JR (jump register) qui branche à l’adresse contenue dans un registre.
a. [3 pts] Expliquez brièvement les modifications à faire au processeur actuel. Indiquez ce qu’il faudra modifier au
chemin des données (Fig. 8-12, p.8-16), et à l’unité de contrôle (Fig. 8-15, p.8-24). Comment les deux nouvelles
instructions pourrait être codées (Tab. 8-5 et 8-6, p.8-25) pour que leur implémentation dans le processeur actuel
soit simple.
Pour les sous-questions suivantes, indiquez les lignes VHDL à ajouter/modifier, dans le contrôle (Exemples 8-13 et
8-14, p.8-28 et 8-29) et si nécessaire dans le chemin de données (Exemples 8-8 à 8-11, p.8-19 à 8-22).
b. [2 pts] Modifiez les branchements pour qu’ils soient relatifs.
c. [4 pts] Ajoutez l’instruction JAL.
Considérez le circuit numérique suivant. Supposez que les bascules ont un temps de préparation de 1 ns, un
temps de maintien de 0,5 ns et un délai de propagation de 2 ns. Les délais des autres composantes sont indiqués.
Négligez les délais des interconnexions. Négligez toute contrainte de synchronisation avec les entrées a et b et la
sortie f.
a. [4 pts] Identifiez clairement le(s) chemin(s) à surveiller pour savoir si les bascules seront stables. Déterminez la
fréquence maximale d’horloge dans le cas où le délai sur l’horloge est nul (aucun déphasage).
b. [4 pts] En gardant le délai sur l’horloge nul, et sans avoir à changer le comportement sur les entrées (même
valeurs envoyées aux mêmes cycles), expliquez comment il est possible d’accélérer ce circuit en utilisant des
bascules placées différemment et dites quelle nouvelle période d’horloge ceci donnerait.
Solutions du final
26 avril 2008, 9h30 – 12h
1.
a)
b)
c)
architecture arch of exponentiateur is
signal A, B, C : unsigned(W - 1 downto 0);
signal X : unsigned(W - 1 downto 0);
constant compteurmax : positive := W - 1;

signal compteur : natural range 0 to compteurmax;
type type_etat is (attente, carre, multiplie);

begin
process (CLK, reset)
begin
if rising_edge(CLK) then
if reset = '1' then
etat <= attente;
else
case etat is
when attente =>
fini <= '1';
if chargeA = '1' then
A <= entree;
end if;
if chargeB = '1' then
B <= entree;
end if;
compteur <= compteurmax;
if go = '1' then
fini <= '0';
C <= to_unsigned(1, W);
etat <= multiplie;
else
etat <= attente;
end if;
when multiplie =>
if (B(W-1) = '1') then
C <= RESIZE(C*X, W); -- C <= RESIZE(C*A, W);
end if;
if (compteur = 0) then
etat <= attente;
else
etat <= carre;
end if;
when carre =>
compteur <= compteur - 1;
C <= RESIZE(C*X, W); -- C <= RESIZE(C*C, W);
B <= shift_left(B, 1);
etat <= multiplie;
when others =>
etat <= attente;
end case;
end if;
end if;
end process;
X <= A when etat = multiplie else C;

-- signal de sortie
resultat <= C;
end arch;
2.
clk <= not clk after period / 2;
process
variable A : natural range 0 to 2 ** W - 1 := 0;
variable B : natural range 0 to 2 ** W - 1 := 0;
variable AexposantB : natural range 0 to 2 ** W - 1 := 0;
variable seed1 : positive := 1;

variable aleatoire : real;
begin
chargeA <= '0';
chargeB <= '0';
go <= '0';
reset <= '1';

wait until rising_edge(clk);
wait until falling_edge(clk);
reset <= '0';
while true loop

uniform(seed1, seed2, aleatoire);
A := integer(floor(aleatoire * real(2 ** (W/2)))); -- 0 <= t <= 2**(W/2)
B := integer(floor(aleatoire * real(2 ** (W/2)))); -- 0 <= t <= 2**(W/2)
AexposantB := (A**B) mod (2**W);

chargeA <= '1'; chargeB <= '0';
entree <= to_unsigned(A, W);

chargeA <= '0'; chargeB <= '1';
entree <= to_unsigned(B, W);
go <= '1';

go <= '0';
wait until rising_edge(fini);

assert to_integer(resultat) = AexposantB report "erreur!" severity failure;
end loop;
end process;
3.
a) Pour JAL il faut pouvoir envoyer le PC au bloc de registres (ajouter un choixSource pour PC). Pour
JR il faut que le contrôleur puisse envoyer la valeur d’un registre dans le PC (B envoyé au contrôleur).
Le contrôleur doit faire une adition sur le PC, plutôt que d’y écrire la valeur venant de l’instruction.
JAL et JR peuvent être comme les autres branchements, avec un numéro « condition » différent. Ici on
a choisi "0101" pour JAL, il faudra faire attention qu’il soit considéré comme inconditionnel.
b)
machine à états, dans « when jump, if… then »:
PC <= PC + to_integer(signed(IR(7 downto 0)));
c)
multiplexeur :
changer le « range » de 3 à 4;
ajouter : when 4 => donnee <= PC;
signaux de contrôle :
with etat select choixSource <= 0 when opUAL, 4 when jump, 3 when others;
choixCharge <= 15 when etat = jump else to_integer(unsigned(IR(11 downto 8)));
charge <= '1' when etat = opUAL or etat = lireMemoire or (etat = jump and IR(11 downto 8) =
"0101") else '0';
machine à états, dans « when jump, if… »:

ajouter: or (IR(11 downto 8) = "0101")
4.
a)
Chemin long : A/B xor nand nand D d’un délai de 2+5+2+2 = 11ns.
Chemins courts : A/B/C nand nand D d’un délai de 2+2+2 = 6ns.
D C d’un délai de 2ns.
Avec le temps de préparation de 1ns, il faut une période d’au moins 11+1 = 12ns (83MHz).
b)
Oui, par « retiming » on peut déplacer la bascule « D » et la remplacer par 4 bascules aux entrées du
premier niveau de portes nand. Le chemin critique devient alors 5ns (une porte xor), donc 6ns de
période (166MHz).
Examen intra
14 mars 2008
Durée : 2h.
Pondération : 20 %.
Documentation : Toute permise.
Calculatrice : Programmable permise.
Directives particulières : Ordinateurs interdits (une calculatrice exécutant du VHDL est un ordinateur), répondre à
toutes les questions, la valeur de chaque question est indiquée.
Tous les codes VHDL font : library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all;
Nous voulons faire un comparateur séquentiel série, qui compare X et Y (nombres binaires non signés), entrés de
manière sérielle à partir des bits de poids faible, et qui nous dit si X<Y, X=Y ou X>Y. Les entrées du circuit sont
l’horloge, le signal d’initialisation, Xi et Yi , et les sorties sont X<Y et X=Y (les deux sorties étant fausses si
X>Y).
a. [2 pts] Donner le VHDL synthétisable d’un circuit combinatoire qui compare un seul bit de X et Y et dit si Xi=Yi
ou Xi<Yi (respectivement egali et petiti). N’utilisez pas de process pour décrire ce circuit simple.
entity compareBit is
port (
Xi, Yi : in std_logic;
egali, petiti : out std_logic
);
end compareBit;
architecture arch of compareBit is
...
b. [2 pts] Donner le diagramme d’états pour un circuit séquentiel qui, à tout moment, nous donne la comparaison des
nombres jusqu’à présent. Autrement dit egal sera vrai si Xi..0=Yi..0 et petit sera vrai si Xi..0<Yi..0. Les entrées
sont egali et petiti, venant du module compareBit, et les sorties sont egal et petit. (Vous pouvez
faire le VHDL en c. puis en extraire le diagramme d’états si vous croyez que c’est plus simple dans ce sens.)
c. [4 pts] Compléter le VHDL synthétisable suivant, pour le circuit séquentiel précédent.
entity compareSerie is
port (
Xi, Yi, clk, init : in std_logic;
egal, petit : out std_logic
);
end compareSerie;
architecture arch of compareSerie is

component compareBit
port( Xi, Yi : in std_logic; egali, petiti : out std_logic );
end component;
...
d. [1 pt] Donner un avantage et un inconvénient de faire la comparaison sérielle à partir des bits de poids faible, par
rapport à la faire à partir des bits de poids fort.
Nous voulons un circuit combinatoire qui prend la sortie d’un compteur de Johnson (registre à décalage circulaire
ayant un inverseur sur la boucle) et nous donne un compte binaire standard. La sortie sera 0 lorsque le compteur a
des zéros partout, 1 lorsque le compteur a un 1 dans son bit de poids faible, 2 lorsque le compteur a deux 1 dans
ses bits de poids faibles, etc., jusqu’à nétats-1 lorsque le compteur a un 1 dans son bit de poids fort (où nétats est
le nombre d’états du compteur de Johnson).
a. [5 pts] Compléter le code VHDL générique ci-dessous, pour qu’il se synthétise en un circuit combinatoire correct
pour toute taille de compteur. Votre circuit peut donner une sortie quelconque si l’entrée n’est pas un compte de
Johnson valide.
entity johnsonAbinaire is
generic (
n : positive := 4; -- nombre de bits du compteur de Johnson
nB : positive := 3 -- nombre de bits en sortie
);
port (
J : in std_logic_vector(n-1 downto 0); -- l’entrée (compte de Johnson)
B : out std_logic_vector(nB-1 downto 0) -- la sortie (compte binaire)
);
end johnsonAbinaire;
architecture arch of johnsonAbinaire is

...
b. [4 pts] Compléter le banc d’essai pour vérifier le circuit johnsonAbinaire de façon exhaustive (pour les
entrées valides) pour un n donné. Le banc d’essai doit indiquer, à la console seulement, pour quels cas le circuit à
vérifier donne une sortie incorrecte. Définir nB comme le plus petit nombre de bits nécessaire pour représenter la
sortie.
entity johnsonAbinaireTB is
generic ( n : positive := 4 );
end johnsonAbinaireTB;
architecture arch of johnsonAbinaireTB is

component johnsonAbinaire
generic( n : positive; nB : positive );
port( J : in std_logic_vector(n-1 downto 0); B : out std_logic_vector(nB-1 downto 0) );
end component;
constant nB : positive := ...; -- nombre de bits de sortie
signal J : std_logic_vector(n-1 downto 0);
signal B : std_logic_vector(nB-1 downto 0);
begin
UUT : johnsonAbinaire generic map (n => n, nB => nB) port map (J, B);
...
Nous voulons un circuit séquentiel qui décode du morse. Un premier circuit analogique à numérique détecte la
tonalité émise et donne en sortie un 1 lorsqu’elle est détectée et 0 lorsqu’elle ne l’est pas. Le circuit numérique va
ensuite échantillonner la sortie du détecteur, pour compter le temps passé à 1, pour savoir si c’est un bip court
(point) ou long (trait), et le temps passé à 0 pour savoir si c’est l’espace entre deux bips d’une même lettre, ou si
c’est la fin de la lettre.
Expliquer à quoi il faut faire attention lors de l’échantillonnage, pourquoi, et comment le faire correctement.
1.
a)
architecture arch of compareBit is
begin
egali <= '1' when Xi = Yi else '0'; (ou egali <= not (Xi xor Yi);
petiti <= '1' when Xi = '0' and Yi = '1' else '0'; (ou petiti <= (not Xi) and Yi;
end arch;
b)
c)
architecture arch of compareSerie is
component compareBit
port( Xi, Yi : in std_logic; egali, petiti : out std_logic );
end component;
signal egali, petiti : std_logic;

begin
cb: compareBit port map(Xi, Yi, egali, petiti);
process(clk,init)
begin
if init='1' then
egal <= '1';
petit <= '0';
elsif rising_edge(clk) then
if petiti='1' then
petit <= '1';
egal <= '0';
elsif egali='0' then
petit <= '0';
egal <= '0';
end if;
end if;
end process;
end arch;
d)
Poids faible, avantage : La comparaison peut commencer avant avoir fini une opération arithmétique
précédente (les opérations d’aditions et de multiplications ne se font pas à partir des bits de poids fort).
Poids fort, avantage : On peut souvent savoir la réponse avant d’avoir passé tous les bits.
2.
a)
architecture arch of johnsonAbinaire is
begin
process(J)
variable val : integer;
begin
val := 0;
for k in n-1 downto 1 loop
if J(k) /= j(0) then
val := k;
end if;
end loop;
if (J(n-1) = '1') then

val := val+n;
end if;
B <= std_logic_vector(to_unsigned(val, nB));

end process;
end arch;
b)
architecture arch of johnsonAbinaireTB is
component johnsonAbinaire
generic ( n : positive; nB : positive );
port( J : in std_logic_vector(n-1 downto 0); B : out std_logic_vector(nB-1 downto 0) );
end component;
constant nB : positive := integer(ceil(log2(real(n*2-1)))); -- nombre de bits de sortie

signal J : std_logic_vector(n-1 downto 0);
signal B : std_logic_vector(nB-1 downto 0);
begin
UUT : johnsonAbinaire generic map (n => n, nB => nB) port map (J, B);
process
begin
J <= (others => '0');
wait for 10 ns;
for k in 0 to n*2-1 loop

if to_integer(unsigned(B)) /= k then
report "Erreur pour " & integer'image(k) severity error;
end if;
J <= J(n-2 downto 0) & not(J(n-1));
wait for 10 ns;
end loop;
report "fini" severity failure;
end process;
end arch;
3.
(section 7.5 des notes) Il est possible que la bascule qui échantillonne le signal tombe dans un état
métastable, si le moment d’échantillon arrive trop proche d’un moment où le signal échantillonné
change. Il faut utiliser par exemple un circuit à double tampon pour faire un « synchroniseur ». Il faut
aussi faire attention que la fréquence d’échantillonnage soit assez grande.
Examen final
Décembre 2009
Durée: 2h30.
Pondération: 40%.
Documentation: Une feuille recto verso 8.5”×11” ou A4 permise.
Directives particulières:
• Ordinateurs interdits
• Répondre à toutes les questions, la valeur de chaque question est indiquée.
• Répondre dans le cahier fourni et soumettre la page du questionnaire indiquée.
• Ne pas remettre le questionnaire.
• Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute sup-
position que vous faites.
INF3500 – examen final – décembre 2009
Les nombres de Fibonacci sont définis comme suit :

1 n = 1,2
Fn =
Fn−1 + Fn−2 n>2
Le tableau suivant donne les 9 premiers nombres de Fibonacci :
n 1 2 3 4 5 6 7 8 9
Fn 1 1 2 3 5 8 13 21 34
Faites la conception d’un processeur qui calcule le n-ième nombre de Fibonacci (0 < n < 40). En plus
d’une horloge et d’un signal de réinitialisation, le processeur doit avoir en entrée un port n pour l’indice
du nombre de Fibonnacci à calculer et un port de contrôle go pour indiquer que le port n peut être lu et
que les calculs doivent débuter. En sortie, le processeur doit avoir un port Fn pour le résultat et un port de
contrôle fini pour indiquer que la sortie est valide.
a. Donnez un schéma du chemin des données du processeur.
b. Donnez le diagramme d’états de l’unité de contrôle du processeur.
Solutions.
a.
b.
Une porte universelle peut réaliser toutes les fonctions logiques possibles de ses entrées. La fonction dési-
rée est spécifiée par un port de contrôle spécial. Pour une porte universelle à deux entrées x et y, il y a 16
possibilités de fonctions logiques, tel que montré dans la table de vérité combinée suivante.
On observe que les fonctions F0 et F15 sont des constantes, alors que les fonctions F3, F5, F10 et F12 se
réduisent à des fonctions à une seule variable.
x y Fo F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
1 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
Donnez une architecture pour l’entité suivante en VHDL synthétisable, afin de réaliser une porte univer-
selle à deux entrées.
library ieee;
entity porteUniverselle2 is
port (
x, y : in std_logic;
op : in unsigned(3 downto 0); -- opération à effectuer
F : out std_logic
);
end porteUniverselle2;
Solution :
-- solution ‘simple’ -- solution la plus simple
architecture arch of porteUniverselle2 is architecture arch2 of porteUniverselle2 is
begin begin
process (x, y, op) F <= op(to_integer(not(unsigned(x & y))));
begin end arch2;
case to_integer(op) is
when 0 => F <= '0';
when 1 => F <= x and y;
when 2 => F <= x and not(y);
when 3 => F <= x;
when 4 => F <= not(x) and y;
when 5 => F <= y;
when 6 => F <= x xor y;
when 7 => F <= x or y;
when 8 => F <= not(x or y);
when 9 => F <= not(x xor y);
when 10 => F <= not(y);
when 11 => F <= not(not(x) and y);
when 12 => F <= not(x);
when 13 => F <= not(x and not(y));
when 14 => F <= not(x and y);
when 15 => F <= '1';
when others => F <= 'X';
end case;
end process;
end arch;
Un registre à décalage à rétroaction linéaire (RDRL) peut générer une suite de nombres pseudo-aléatoires.
Le diagramme suivant représente un RDRL à 8 bits. Le RDRL est composé de 8 bascules et de 3 portes
OUX. Chaque bascule est menée par une horloge, un signal de chargement et un signal de réinitialisation
(‘0’) ou d’initialisation (‘1’). Le signal de sortie n est le contenu du registre. Donnez une description en
VHDL synthétisable de ce RDRL.
Solution :
library IEEE;
entity RDRL is
port (
reset_n, clk, compte : in std_logic;
n : out std_logic_vector(7 downto 0)
);
end RDRL;
architecture arch of RDRL is

begin
process(reset_n, clk) is
variable nint : std_logic_vector(7 downto 0);
begin
if reset_n = '0' then
nint := "00000001";
if compte = '1' then
nint := nint(6 downto 0) & (nint(7) xor nint(5) xor nint(4) xor nint(3));
end if;
end if;
n <= nint;
end process;
end arch;
use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.all;
entity add3bits is entity add3bitsTBsimple is

port ( end add3bitsTBsimple;
Cin : in std_logic;
X : in std_logic; architecture arch1 of add3bitsTBsimple is
Y : in std_logic; signal Cin, X, Y, Cout, S : std_logic;
Cout : out std_logic; begin
S : out std_logic UUT : entity add3bits(flotdonnees2)
); port map (Cin, X, Y, Cout, S);
end add3bits; Cin <= '0' after 0 ns;
X <= '0' after 0 ns, '1' after 10 ns;
architecture flotdonnees2 of add3bits is Y <= '0' after 0 ns;
signal T1 : std_logic; end arch1;
signal T2 : std_logic;
signal T3 : std_logic;
begin
S <= T1 xor Cin;
Cout <= T3 or T2;
T1 <= X xor Y;
T2 <= X and Y;
T3 <= Cin and T1;
end flotdonnees2;
a. Donnez la liste des événements, telle qu’elle pourrait être dressée par un simulateur qui exécuterait le
banc d’essai.
b. En vous basant sur votre liste des événements, donnez la valeur de tous les ports et signaux internes du
module combinatoire en fonction du temps, en tenant compte des délais deltas.
Solution :
a. Liste des événements
À t = 0 + 0 , initialisation de la simulation (tout à ‘U’)
À t = 0 + 1 , assignation de 000 à X, Y, Cin
À t = 0 + 2 , évaluation des signaux T1, T2, T3 et S (provoquées par les changements sur X, Y, Cin)
À t = 0 + 3 , évaluation de T3, S et Cout (provoquées par les changements sur T1, T2, T3)
Aucun nouvel événement n’est ajouté à la liste d’événements.
À t = 10 ns + 0 , assignation de 1 à X
À t = 10 ns + 1 , évaluation de T1 et T2 (provoquées par le changement sur X)
À t = 10 ns + 2 , évaluation de T3 et de S (provoquées par le changement sur T1)
b.
École Polytechnique de Montréal page 6/9 Département de génie informatique

inform et génie logiciel
Considérez le circuit suivant. Les délais des portes logiques combinatoires sont indiqués. Les bascules ont
un temps de propagation de 2 ns, un temps de préparation de 1 ns, et un temps de maintien de 0.5 ns.
Chaque fil du circuit a un délai de propagation de 0.1 ns.
a. Supposez que toutes les bascules sont alimentées par le même signal d’horloge. Donnez le chemin cri-
tique en indiquant les composantes sur ce chemin, et donnez la fréquence maximale d’horloge.
b. On veut maximiser la fréquence d’horloge du circuit en insérant des registres de pipeline. Les registres
ajoutés ont les mêmes caractéristiques que les registres actuels du circuit, et chaque fil ajouté a un délai de
propagation de 0.1 ns. Il n’y a pas de déphasage d’horloge. En supposant que vous pouvez ajouter autant
de registres que vous le voulez, quelle est la fréquence maximale d’opération du circuit? Expliquez com-
plètement votre réponse.
c. Le circuit initial sans pipeline a été disposé de façon inappropriée sur une puce, et la bascule A reçoit
un signal d’horloge qui est 3 ns en retard sur les signaux d’horloge des autres bascules. Quelle est la fré-
quence maximale d’horloge? Expliquez complètement votre réponse.
Solution :
a. Bascule C, OUX, ETX, NOU, OU, Bascule F. Délai : 2 + 0.1 + 4 + 0.1 + 4 + 0.1 + 2 + 0.1 + 3 + 0.1 =
15.5 ns, + tsu(1 ns) = 16.5 ns. Fmax = 60.6 MHz.
b. On ajoute une bascule après chaque porte logique. Il en faut une aussi sur le fil entre la bascule C et
l’entrée et la porte ETX. Le chemin critique débute dans une bascule, passe à travers la porte OUX ou la
porte ETX, et va à une autre bascule. Le délai est 2 + 0.1 + 4 + 0.1 + tsu(1ns) = 7.2 ns, fmax = 138.8
MHz.
c. Le chemin critique devient alors bascule A, ET, OU, NON-ET, OU, bascule F. Délai : tcs(3 ns) + 2 +
0.1 + 3 + 0.1 + 3 + 0.1 + 2 + 0.1 + 3 + 0.1 + tsu(1 ns) = 17.5 ns. Fmax = 57.1 MHz.
La déclaration suivante d’entité en VHDL est pour un circuit combinatoire calculant la médiane d’un
ensemble de trois nombres. Dans un groupe de nombres, la médiane est la valeur centrale du groupe une
fois les nombres placés en ordre croissant ou décroissant. Vous devez choisir des vecteurs de test pour
vérifier le fonctionnement d’une architecture pour cette entité, avec W = 16, mais vous n’avez pas accès
au code de cette architecture. Supposez que vous avez accès à un simulateur capable d’effectuer 1 million
de tests par seconde.
Décrivez trois stratégies que vous utiliseriez pour faire la vérification de ce circuit, en donnant des exem-
ples de vecteurs de test pour chacune des stratégies. Justifiez complètement votre réponse.
library IEEE;
entity mediane is
generic (
W : positive := 16 -- nombre de bits des opérandes
);
port (
A, B, C : in signed(W - 1 downto 0);
lamediane : out signed(W - 1 downto 0)
);
end mediane;
Solution :
Il y a 248 vecteurs de tests possibles. À un million de tests par secondes, il faudrait presque 9 ans pour les
essayer tous. Un test exhaustif est donc impossible.
1. Analyse des valeurs limites. Pour chacune des trois entrées, on appliquerait sa valeur minimale, une
valeur supérieure à sa valeur minimale, sa valeur nominale, sa valeur maximale, et une valeur juste infé-
rieure à la valeur maximale. Cela fait cinq possibilités. On composerait 5 × 5 × 5 = 125 vecteurs énumé-
rant toutes les combinaisons possibles pour les trois entrées A, B, C.
2. Partitionnement en classes : valeurs positives, valeurs négatives et 0. Un test fort contiendrait des vec-
teurs de test avec toutes les combinaisons possibles.
3. Cas spéciaux où deux des trois ou bien les trois valeurs sont identiques.
4. Avec le temps qui reste, on appliquerait des vecteurs de test pseudo-aléatoires.
Réponses brèves.
a. Donnez trois qualités d’un bon ensemble de vecteurs de test.
Solution : efficacité, aide à déterminer la source des bogues, reproductible, automatisé, temps d’exécution
raisonnable
b. Énoncez trois types d’avertissements qu’un analyseur statique de code VHDL pourrait donner.
Solutions possibles : Opérandes de largeurs différentes dans une expression; Énoncés conditionnels dont
tous les cas ne sont pas couverts et qui créent des états implicites; Énoncés conditionnels qui se recou-
pent; Nom d’entité différent du nom du fichier; Insertion de signaux de contrôle dans le chemin d’une
horloge; Signaux ou variables qui ne sont pas initialisés avant d’être utilisés; Signaux ou variables aux-
quels on n’assigne jamais de valeur ou qui ne sont jamais utilisés; Expression constante dans une structu-
re de condition, etc.
c. Expliquez deux problèmes qui peuvent survenir si on utilise un commutateur d’une planchette
d’expansion (contrôlé par un humain) comme entrée directe pour une machine à états implémentée dans
un FPGA sur une carte de développement.
Solutions : 1. Le commutateur rebondit, ce qui crée plusieurs entrées de suite qui changent de valeur. 2.
Le commutateur peut être activé pendant une période interdite d’une bascule, la plaçant dans un état mé-
tastable. 3. Si plusieurs bascules dépendent de la valeur du commutateur, il est possible que certaines
d’entre elles voient une valeur différente des autres si le commutateur est activé juste au mauvais mo-
ment, plaçant la machine à états dans un état interdit.
d. Donnez deux exemples de code VHDL non synthétisable.
Solutions possibles : boucles dont les bornes ne sont pas connues statiquement au moment de la synthèse,
clause after, opérateur de division pour un diviseur qui n’est pas statiquement une puissance de deux,
variable ou signal non constant de type real, entrées et sorties par fichiers, etc.
e. Expliquez les différences entre un CPLD et un circuit PAL.
Solution : Les CPLD sont une extension naturelle des circuits PAL. Un CPLD contient plusieurs PALs
reliés par un réseau d’interconnexions.
f. Expliquez la différence entre les concepts de « débit » et de « latence ».
Solution : Le débit est le nombre de résultats produits par unité de temps. La latence est le temps nécessai-
re pour produire un résultat à partir du moment où les données nécessaires pour le calculer sont disponi-
bles.
Examen intra
Jeudi 22 octobre 2009
Durée: 2h.
Pondération: 20%.
Ordinateurs interdits
Répondre à toutes les questions, la valeur de chaque question est indiquée.
Répondre dans le cahier fourni et soumettre la page du questionnaire indiquée.
Ne pas remettre le questionnaire.
INF3500 – contrôle périodique – 22 octobre 2009
Donnez une architecture pour les entités suivantes en VHDL synthétisable, en respectant les spécifica-
tions données en commentaires.
a.
library ieee;
-- bascule T
-- La sortie de la bascule T passe de 0 à 1 ou de 1 à 0 sur une
-- transition positive d'horloge quand l'entrée enable = 1.
-- Sa sortie est inchangée quand enable = 0.
-- La sortie est remise à 0 de façon asynchrone quand reset_n = 0.
entity basculeT is
port (
reset_n, clk, enable : in std_logic;
T : out std_logic
);
end basculeT;
Une solution possible :

architecture arch of basculeT is
signal Ttemp : std_logic;
begin
T <= Ttemp;
process(reset_n, clk) is
begin
Ttemp <= '0';
if enable = '1' then
Ttemp <= not(Ttemp);
end if;
end if;
end process;
end arch;
b.
library ieee;
-- compteurSecondes
-- La sortie secondes de ce compteur est incrémentée à chaque transition positive
-- d'horloge, allant de 0 à 59 puis recommençant à 0.
-- La sortie uneminute est menée à 1 pour une période d'horloge quand le compte
-- passe de 59 à 0, et à 0 autrement.
-- Le compte est remis à zéro de façon synchrone quand reset_n = 0.
entity compteurSecondes is
port (
reset_n, clk1Hz : in std_logic;
secondes : out unsigned(5 downto 0);
uneminute : out std_logic
);
end compteurSecondes;

architecture arch of compteurSecondes is
signal secondes_t : natural range 0 to 59;
begin
secondes <= to_unsigned(secondes_t, secondes'length);
process(clk1Hz) is
begin
if rising_edge(clk1Hz) then
secondes_t <= 0;
uneminute <= '0';
else
if secondes_t = 59 then
secondes_t <= 0;
uneminute <= '1';
else
secondes_t <= secondes_t + 1;
uneminute <= '0';
end if;
end if;
end if;
end process;
end arch;
Considérez le code VHDL suivant. Le circuit accepte en entrée un nombre non signé encodé sur 10 bits,
et il a trois sorties. Ces sorties donnent le nombre de centaines, de dizaines et d’unités (de 0 à 9 inclusi-
vement, encodées sur 4 bits) du nombre. La sortie erreur est activée si le nombre est égal ou supérieur à
1000.
Donnez un diagramme correspondant composé de modules combinatoires (multiplexeurs, décodeurs, etc.)
et d’unités fonctionnelles (additionneurs, multiplicateurs, comparateurs, etc.) tel qu’il pourrait être généré
par un processus de synthèse.
library ieee;
entity unsigned2dec is
port(
centainesBCD, dizainesBCD, unitesBCD : out unsigned(3 downto 0);
erreur : out std_logic
);
end unsigned2dec;
architecture arch of unsigned2dec is

begin
erreur <= '1' when nombre >= 1000 else '0';
process(nombre)
variable n, c, d, u : natural := 0;
begin
n := to_integer(nombre);
for centaines in 9 downto 1 loop

c := 0;
if n >= centaines * 100 then
c := centaines;
exit;
end if;
end loop;
n := n - c * 100;
for dizaines in 9 downto 1 loop

d := 0;
if n >= dizaines * 10 then
d := dizaines;
exit;
end if;
end loop;
u := n - d * 10;
centainesBCD <= to_unsigned(c, 4);

dizainesBCD <= to_unsigned(d, 4);
unitesBCD <= to_unsigned(u, 4);
end process;
end arch;
Solution :
#$%&
! !
" "
' #$%&
! ! ! !
#$%&
Considérez le diagramme suivant, qui représente le chemin des données d’un processeur qui implémente
l’algorithme CORDIC. L’algorithme CORDIC permet entre autres de calculer les fonctions trigonométri-
ques à l’aide d’un processus itératif. Le diagramme comporte quatre registres, x, y, z et i; les autres blocs
sont combinatoires.
Les registres x, y et z contiennent des valeurs signées en complément à deux représentées sur 12 bits. Les
deux décaleurs produisent des versions décalées des contenus des registres x et y, et le nombre de posi-
tions de décalage est donné par la valeur du registre i. Les trois blocs d’addition/soustraction sont contrô-
lés par le signe de z : quand z est positif, celui du milieu additionne et les autres soustraient, et inverse-
ment quand z est négatif. Le compteur i débute à 0 et compte jusqu’à 7 puis s’arrête. Le bloc (i) est une
mémoire ROM de huit valeurs signées représentées sur 12 bits.
Donnez le code pour un processus qui implémente les registres x, y, z et i tels que montrés dans le dia-
gramme. Vous n’avez pas à écrire de code pour le chargement des registres, pour les sorties du système,
ni pour le contrôle du chemin des données. Supposez que x, y, z et i sont déclarés comme des signaux de
type signed.
Solution :
process(clk)
begin
if rising_edge(clk) then
if z(z'left) = '0' then
x <= x - shift_right(y, i);
y <= y + shift_right(x, i);
z <= z - alpha(i);
else
x <= x + shift_right(y, i);
y <= y - shift_right(x, i);
z <= z + alpha(i);
end if;
if (i < 7) then
i <= i + 1;
end if;
end if;
Pour l’entité unsigned2dec décrite à la question #2, composez un banc d’essai qui effectue un test ex-
haustif et qui vérifie que la sortie est valide en tout temps. Une sortie valide indique correctement les uni-
tés, les dizaines et les centaines pour des nombres entre 0 et 999, inclusivement. Pour les autres nombres,
le signal d’erreur doit être actif. Dans le cas d’une erreur, votre banc d’essai doit simplement afficher le
message « erreur » à la console et se terminer.
Complétez le code VHDL suivant en donnant l’architecture.
library ieee;
entity unsigned2dec_TB is
end unsigned2dec_TB;
architecture TB_ARCHITECTURE of unsigned2dec_TB is

--- votre code ici
begin
--- votre code ici
end TB_ARCHITECTURE;
Une solution possible:

signal nombre : unsigned(9 downto 0);

signal centainesBCD, dizainesBCD, unitesBCD : unsigned(3 downto 0);
signal erreur : std_logic;
begin
UUT : entity unsigned2dec(arch)

port map (nombre, centainesBCD, dizainesBCD, unitesBCD, erreur);
process
variable n : natural;
begin
for k in 0 to 1023 loop
nombre <= to_unsigned(k, nombre'length);
wait for 10 ns;
n := to_integer(centainesBCD) * 100
+ to_integer(dizainesBCD) * 10
+ to_integer(unitesBCD);
if (k <= 999) then
assert erreur = '0' report "erreur!" severity failure;
assert to_integer(centainesBCD) <= 9 report "erreur!" severity failure;
assert to_integer(dizainesBCD) <= 9 report "erreur!" severity failure;
assert to_integer(unitesBCD) <= 9 report "erreur!" severity failure;
assert n = k report "erreur!" severity failure;
else
end if;
end loop;
end process;
Réponses brèves.
a. Considérez le code VHDL suivant. Quelle valeur prendra le port F lors de la simulation? Pourquoi?
library IEEE;
entity exempleSignaux is
port (F : out std_logic);
end exempleSignaux;
architecture arch1 of exempleSignaux is
begin
F <= '1';
F <= '0';
end arch1;
Solution : le port F prendra la valeur ‘X’ parce qu’il a deux sources de deux valeurs différentes.
b. Considérez le code VHDL suivant. Quelle valeur prendra le port F lors de la simulation si A = ‘1’?
Pourquoi?
library IEEE;
port (A : in std_logic; F : out std_logic);
end exempleSignaux;
begin
process(A)
begin
F <= A;
F <= not(A);
end process;
end arch2;
Solution : le port F prendra la valeur ‘0’ parce que dans le processus c’est la dernière assignation à F qui
sera gardée.
c. En VHDL, les types STD_LOGIC_VECTOR, UNSIGNED et SIGNED sont très utilisés pour la simulation et la
synthèse de système numériques. Les trois types ont exactement la même définition :
type STD_LOGIC_VECTOR is array ( NATURAL range <>) of STD_LOGIC;
type UNSIGNED is array ( NATURAL range <>) of STD_LOGIC;
type SIGNED is array ( NATURAL range <>) of STD_LOGIC;
Expliquez la nécessité d’avoir ces trois types et ce qui rend l’utilisation de chacun distincte des autres.
Solution : Les trois types ont des utilisations différentes. Le type STD_LOGIC_VECTOR est utilisé pour
les valeurs logiques, les deux autres pour des valeurs numériques. L’utilisation de chaque type est distinc-
te à cause des fonctions, procédures et opérateurs qui sont définis et/ou surchargés pour chaque type.
d. Il y a quatre considérations fondamentales pour l’implémentation d’un système numérique, dont la
taille du système. Énumérez les trois autres.
Solution : Taux de traitement, puissance consommée et précision des calculs.
e. Nommez et décrivez brièvement une des trois technologies de programmation les plus populaires pour
FPGA.
Solution : SRAM, antifusibles et Flash – voir les notes de cours, section 3.7.7.
f. Pour le FPGA XC2VP30-FF896 utilisé dans les laboratoires, il y a deux façons d’implémenter de la
mémoire RAM : la mémoire RAM distribuée (Distributed RAM) et la mémoire RAM bloc (Block RAM).
Décrivez brièvement ces deux ressources et expliquez leurs différences.
Solution : La mémoire bloc est composée de modules spécifiques intercalés à travers les blocs de logique
configurable du FPGA. La mémoire distribuée utilise les ressources internes de blocs de logique configu-
rable.
Illustrez, avec un diagramme, le flot de conception que vous avez suivi dans les laboratoires du cours
INF3500 à ce jour, de la description du design à la vérification du fonctionnement de la puce.
Solution : figure 4-1 des notes de cours
Considérez le code VHDL suivant. Montrez, sur le diagramme suivant d’une partie d’un FPGA, un résul-
tat possible de la synthèse et de l’implémentation de ce code. Indiquez directement sur le dessin où cha-
que signal se situe, les interconnections entre les blocs, et le contenu de chacune des tables de conversion
que vous utilisez.
Remettez la feuille dans votre cahier d’examen.
library IEEE;
entity cctsequentielex1 is
port (
reset : in STD_LOGIC;
CLK : in STD_LOGIC;
X : in STD_LOGIC;
Z : out STD_LOGIC
);
end cctsequentielex1;
architecture arch1 of cctsequentielex1 is

signal A : STD_LOGIC; -- bascule A (en haut)
signal B : STD_LOGIC; -- bascule B (en bas)
begin
begin
A <= '0';
B <= '0';
A <= A xor B;
B <= x or not(B);
end if;
end process;
-- signal de sortie
z <= not(A or B);
end arch1;
Annoter cette page et remettez-la avec votre cahier d’examen
Nom : ____________________________ Matricule : __________________________
Solution :
)
0-
3
) & -
(
#
) ) %+,
! *! 2
)1
.! 2!
/ $
* *-
/ & -
(
#
/ / %+,
! *! 2
/!
2
%+,
%+,
)
0-
) & -
(
#
) ) %+,
! *! 2
)1
0
4
.
.! 2!
/
*-
/ & -
(
#
/ / %+,
! *! 2
/!
2
%+,
G4 G3 G2 G1 F4 F3 F2 F1
G (A) F (B)
(A) (B) (NC) (NC) (X) (B) (NC) (NC)
0 0 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 0 1 1
0 0 1 0 0 0 0 1 0 1
0 0 1 1 0 0 0 1 1 1
0 1 0 0 1 0 1 0 0 0
0 1 0 1 1 0 1 0 1 0
0 1 1 0 1 0 1 1 0 0
0 1 1 1 1 0 1 1 1 0
1 0 0 0 1 1 0 0 0 1
1 0 0 1 1 1 0 0 1 1
1 0 1 0 1 1 0 1 0 1
1 0 1 1 1 1 0 1 1 1
1 1 0 0 0 1 1 0 0 1
1 1 0 1 0 1 1 0 1 1
1 1 1 0 0 1 1 1 0 1
1 1 1 1 0 1 1 1 1 1
G4 G3 G2 G1
G (Z)
(B) (A) (NC) (NC)
0 0 0 0 1
0 0 0 1 1
0 0 1 0 1
0 0 1 1 1
0 1 0 0 0
0 1 0 1 0
0 1 1 0 0
0 1 1 1 0
1 0 0 0 0
1 0 0 1 0
1 0 1 0 0
1 0 1 1 0
1 1 0 0 0
1 1 0 1 0
1 1 1 0 0
1 1 1 1 0
Examen final
19 août 2009
Durée: 2h30.
Pondération: 40%.
tion est indiquée.
Les pages réponses à remplir et à remettre sont à la fin de l’énoncé. N’oubliez pas de préciser votre nom
et numéro de matricule sur chacune des pages réponse.
Question 1. (12 points) – Processeur à but spécifique
Nous désirons concevoir un processeur à but spécifique qui gère une machine à café. L’entité du gestion-
naire de la machine à café est comme suit :
entity gest_machine_a_cafe is
generic (
prix_cafe1 : positive;
prix_cafe2 : positive
);
port (
reset : in std_logic;
clk : in std_logic;
piece_introduite : in unsigned(6 downto 0);
piece_introduite_valide : in std_logic;
choix_cafe : in std_logic;
fermer_entree_piece : out std_logic;
annuler : in std_logic;
servir_cafe : out std_logic;
cafe_servi : in std_logic;
activer_cafe1 : out std_logic;
piece_a_rendre : out unsigned(6 downto 0);
piece_a_rendre_valide : out std_logic
);
end gest_machine_a_cafe;
Le client a le choix entre café1 (choix_cafe = ‘0’) ou café2 (choix_cafe = ‘1’). Les prix des cafés sont des
paramétres génériques : prix_cafe1 et prix_cafe2.
La partie mécanique de la machine à café comprend la fente dans laquelle le client introduit des pièces, la
sortie par laquelle les pièces de la monnaie sont rendues et la structure qui sert les cafés. Ces parties mé-
caniques envoient et/ou recoivent des requêtes au gestionnaire. Ce dernier attend que le client fasse son
choix et qu’il glisse des pièces dans la fente jusqu’à ce que le total des pièces introduites soit supérieur ou
égal au montant du café à servir. Lorsque ce montant est atteint alors un ordre sera émis à la partie méca-
nique pourque le café soit servi (servir_cafe = ‘1’. Ensuite, le gestionnaire calculera le montant de la
monnaie à rendre.
La machine ne peut recevoir ou retourner que des pièces de 1$, 25 cents, 10 cents ou 5 cents.
Le montant de la piece introduite est en cents donc lorsqu’une pièce de 1$ est introduite l’entrée pie-
ce_introduite sera égale à 100.
Pour éviter de considérer la même pièce plusieurs fois, le gestionnaire devra attendre que le signal piè-
ce_introduite_valide transite de ‘0’ à ‘1’ avant de considérer la nouvelle pièce.
Après avoir reçu l’avis que le café est servi (cafe_servi = ‘1’), le gestionnaire procédera à la remise de la
monnaie. Par rapport au montant introduit, le gestionnaire devra émettre des requêtes de remise de pièces.
Donc, par exemple, si le gestionnaire doit remettre 35 cents, il devra émettre l’ordre de remettre une pièce
de 25 cents puis d’une de 10 cents. Les ordres de remise de pièce doit être séparée à savoir que le port
piece_a_rendre_valide doit transiter de ‘1’ à ‘0’, pour que le second ordre soit considéré.
INF3500 – examen intra – 24 février 2009
Pendant que les pièces sont entrées, le client peut décider d’annuler sa commande. Dans ce cas, le port
annuler sera égal à ‘1’ et le gestionnaire devra émettre les ordres de remise de pièces afin de rendre au
client le montant de pièces qu’il avait introduit avant l’annulation.
Pour éviter que le client introduise des pièces pendant que le café est servi ou que la monnaie est remise,
la fente des pièces entrées doit est fermée (fermer_entree_piece = ‘1’).
Les interfaces du gestionnaire de la machine à café se décrivent comme suit :
Port Description
reset Il réintialise les ports et bascules internes du gestionnaire.
clk L’horloge du processeur.
piece_introduite Le montant de la pièce introduite en cents.
piece_introduite_valide La pièce introduite doit être considérée que lorsque ce port est égal à ‘1’. Ce port doit
transiter de ‘0’ à ‘1’ entre l’introduction de deux pièces.
choix_cafe Lorsque ce port a la valeur ‘0’ alors le prix à charger devra correspondre à
prix_cafe1 sinon c’est prix_cafe2 qui sera utilisé.
fermer_entree_piece Le gestionnaire doit mettre ce port à ‘1’ pour éviter que le client continue à intro-
duire des pièces pendant que le café est servi ou que la monnaie est remise. En atten-
dant que le client introduise une nouvelle pièce et que le montant d’un café soit in-
troduit, le gestionnaire mettra ce port à ‘0’.
annuler Lorsque ce port à la valeur ‘1’, cela signifie que le client veut annuler sa commande
et reprendre ses pièces. L’ordre d’annulation ne sera pas considéré pendant qu’un
café est servi ou que la monnaie est rendue.
servir_cafe Ce port est égal à ‘1’ lorsque le total des pièces introduites est supérieur ou égal au
montant du café à servir. Ce port sera égal à ‘1’ jusqu’à ce que le café soit servi
(cafe_servi=‘1’), ensuite il retombera à ‘0’.
activer_cafe1 Ce port est égal à ‘1’ quand le montant du café a été introduit et que choix_cafe est
égal a ‘1’.
égal à '0'.
cafe_servi Ce port est égal à ‘1’ pour signifier que le café a été servi au client. Le gestionnaire
devra remettre la monnaie du client s’il y a lieu.
piece_a_rendre Le montant de la pièce à rendre.
piece_a_rendre_valide Lorsque ce port est égal à ‘1’, la partie mécanique sortira la pièce équivalente au
montant sur le port “piece_a_rendre”.
Pour concevoir le processeur à but spécifique, vous devez :

a) Compléter le diagramme de l’architecture simplifiée de votre circuit en montrant les signaux et
ports qui sont utilisés par le chemin de données et l’unité de contrôle. (4 points)
Détachez et remettez la page réponse de la question 1.a avec votre cahier d’examen.
b) Donner le diagramme de la machine à états de l’unité de contrôle. (4 points)
c) Donner le diagramme du chemin de données de votre circuit. (4 points)
Solution
a. le diagramme de l’architecture simplifiée

decrementer_monnaie
accumuler_total
init_monnaie
total_atteint
annuler_int
monnaie
init_total
b. le diagramme de la machine à états de l’unité de contrôle
pie
c e_
int
rod
uit
e _v
ali
de
= ‘1’
an
nu
le
r=
’1
'
ca
fe
_s
er
vi
=’
1'
c. Le diagramme du chemin de données
Question 2. Questions brèves (4.5 points)
a. Citez 4 technologies de logique programmable (1 point).

b. Citez 4 composantes (autres que les LUT, multiplexeurs et bascules) qu’on peut retrouver dans un
FPGA (1 points).
c. Énumérez 2 conditions d’opérations qui ont un impact sur le délai de propagation d’une composante
(0.5 point)
d. Quelle technique de génération de vecteurs de tests serait la plus appropriée pour tester une machine à
états? Expliquez pourquoi. (1 point)
e. Comparez les SRAM et les DRAM? (un avantage et un inconvénient). (1 point)
Solution
a. ROM, PLA, PAL, FPGA
b. CLB, arbre d’horloge, IOB port, block RAM, processeur, bloc DSP tel que des MAC, logique
d’interconnexion.
c. Temperature, tension d’alimentation, la charge menée par la composante.
d. Les circuits de machine à états devraient être vérifiés par des vecteurs exhaustifs afin de
s’assurer que tous les états de la machine ont un comportement attendu.
e. SRAM : vitesse d’accès plus rapide mais elles nécessitent plus de portes logiques
DRAM : elles nécessitent un rafraichissement périodique sinon les données seront perdues,
mais elles nécessitent moins de portes logiques.
Question 3. Circuit séquentiel (9 points)
Soit le circuit gestionnaire_feux dont l’entité est décrite comme suit. Ce contrôleur de feux gère la circu-
lation à une intersection de voies. Les voies sont illustrées par la figure suivante.
Route Secondaire
(RS)
senseur
Route Principale
(RP)
Route Principale
(RP)
Nord
Route Secondaire
Ouest Est
(RS)
Sud
À cette intersection, les voitures de la voie secondaire ne peuvent que tourner vers la gauche ou vers la
droite. Étant donné que le flôt de voitures venant du Nord de la voie secondaire est faible, un senseur a été
placé afin que le feu autorisant les voitures venant du Nord ne soit vert que lorsqu’au moins une voiture y
est présente (senseur=’1’).
Les voitures de la voie principale circuleront lorsque leurs feux seront vert ou jaune. Ces derniers ne peu-
vent circuler que d’Est en Ouest.
L’entité du gestionnaire de feux gest_feux est décrite comme suit :
entity gest_feux is
generic (
Duree_Vert : positive;
Duree_Jaune : positive
);
port (
clk : in std_logic;
senseur : in std_logic;
FRP : out std_logic_vector (2 downto 0);
FSud : out std_logic_vector (2 downto 0);
FNord : out std_logic_vector (2 downto 0)
);
end gest_feux;
La machine à états qui décrit le comportement du gestionnaire de feux est comme suit :

Donnez le code VHDL de l’architecture de la machine à états du gestionnaire de feux

gest_feux. Le reset du circuit est asynchrone.
En sachant que les valeurs des feux sont énumérées comme suit :
• ROUGE = "100";
• VERT = "001";
• JAUNE = "010".
Solution
library ieee;
entity gest_feux is
generic (
);
port (
clk : in std_logic;
);
end gest_feux;
architecture beh of gest_feux is

type etat_t is (eteindrefeux, FRP_V, FRP_J, FSUD_V, FSUD_J, FNORD_V, FNORD_J);
signal etat : etat_t;
signal compteur : integer;
begin -- beh
process (clk, reset)
begin -- process
if reset = ‘1’ then -- asynchronous reset (active low)
etat <= eteindrefeux;
compteur <= Duree_Vert-1;
FRP <= "000";
FSud <= "000";
FNord <= "000";
elsif clk'event and clk = ‘1’ then -- rising clock edge
FRP <= "000";
FSud <= "000";
FNord <= "000";
-- le compteur sera reinitialise lors de la transition entre 2 etats

case etat is
when eteindrefeux =>
etat <= FRP_V;
-- feux de la route principale sont vert
when FRP_V =>
FRP <= "001";
FSUD <= "100";
FNord <= "100";
if compteur = 0 then
etat <= FRP_J;

compteur <= Duree_Jaune - 1;
end if;
-- feux de la route principale sont jaune
when FRP_J =>
FRP <= "010";
FSUD <= "100";
FNord <= "100";
if senseur = ‘1’ then
etat <= FNORD_V;
else
etat <= FSUD_V;
end if;
compteur <= Duree_Vert - 1;
end if;
-- feu des voitures venant du sud est vert
when FSUD_V =>
FRP <= "100";
FSUD <= "001";
FNord <= "100";
etat <= FSUD_J;
compteur <= Duree_Jaune-1;
end if;
-- feu des voitures venant du sud est jaune
when FSUD_J =>
FRP <= "100";
FSUD <= "010";
FNord <= "100";
etat <= FRP_V;
end if;
-- feu des voitures venant du nord est vert
when FNORD_V =>
FRP <= "100";
FSUD <= "100";
FNord <= "001";
etat <= FNORD_J;
end if;
-- feu des voitures venant du nord est jaune
when FNORD_J =>
FRP <= "100";
FSUD <= "100";
FNord <= "010";
etat <= FSUD_V;
end if;
when others =>
end case;
end if;
end process;
end beh;
Question 4. Processeur à but général (7 points)
Soit le processeur à but général présenté dans les notes de cours au chapitre 8.
On désire ajouter une seconde mémoire de données dans l’architecture du processeur. Cette mémoire sera
une mémoire de 1024 cases contenant des mots de 16 bits. L’adresse d’un mot à lire ou à écrire d’une des
mémoire de données sera maintenant contenue sur 11 bits en sachant que le bit 10 de l’adresse précise
quelle mémoire de données est concernée par l’accès. Quand le bit est égal à ‘0’ l’accès concerne la mé-
moire de données initiale, sinon l’accès concerne la seconde mémoire (bit 10 = ‘1’). Les bits 9 à 0 préci-
sent la case à accéder selon la mémoire sélectionnée.
Nous rappelons que le registre d’instructions comporte 16 bits dont 4 bits alloués au code de l’instruction,
4 bits pour l’adresse du registre dans lequel la donnée sera lue ou écrite.
a. Donner le nouveau diagramme du chemin de données et préciser les composantes à rajouter

ou à modifier. (3 points)
b. Décrivez les nouveaux signaux ou les modifications effectuées sur certains signaux
du chemin de données. (1 points).
c. Quel sera l’impact de la nouvelle taille d’une adresse de mémoire de données sur l’unité de
contrôle du processeur? Modifiez le diagramme de la machine à états. (3 points)
Détachez et remettez la page réponse de la question 4.c avec votre cahier d’examen.
À titre d’exemple, le diagramme initial du chemin de données du processeur à but général au chapitre 8
des notes de cours est présenté ci-après.
Solution
a.
b. 2 signaux ont été rajoutés :

selmem : sélectionne la donnée qui devra être écrite dans un registre.
lecture/ecriture’2 : active la lecture ou l’écriture d’une donnée dans la seconde mémoire.
c. il faudra un cycle d’horloge de plus pour exécuter les instructions de chargement mémoire.
Question 5. Simulation et Synthèse (7.5 points)
Soit le circuit suivant :
D
AND2
C
B S1
AND1 B1
A AND3 OR1
F1
B2
AND4
XOR1
XOR2 F2
B3
S2
F3
B4 B5
En sachant que les portes ont les délais suivants :

- Les bascules ont un temps de préparation de 1 ns, un temps de maintien de 1 ns et un délai de propa-
gation de 2 ns.
- Les portes logiques ET et OU exclusif à 2 entrées ont un délai de propagation de 2 ns
- Les portes logiques OU et OU-exclusif à 3 entrées ont un délai de propagation de 3 ns.
a. En tenant compte des délais, compléter le chronogramme donné à la page suivante afin de fournir les
variations de S1, S2, F1, F2 et F3 jusqu’au temps t = 60 ns (Remettre la page du chronogramme avec
votre cahier d’examen) (2.5 points).
b. Donnez la période minimale du circuit. Explicitez vos calculs. (1 point)
c. Soit le bloc de logique programmable (CLB) suivant :
Sel1=
IN0
0
4 LUT F1
16x1 1
Sel2=
0
4 LUT F2
16x1 1
IN9
GND VCC
Dans ce dernier, on peut programmer 2 tables de conversion, 2 multiplexeurs. Les entrées IN0 à IN9,
GND et VCC peuvent être connectées à tous éléments du CLB. L’entrée GND permet de propager la va-
leur logique ‘0’ et l’entrée VCC la valeur ‘1’. Les sorties des tables de conversion ou celles des multi-
plexeurs peuvent être connectées à une des sorties F1 et F2.
Proposez un routage possible du circuit dans un FPGA. Vous pouvez instancier autant de CLB que
nécessaire. Montrez les connexions entre les CLB, la valeur des ports de sélection Sel1 et Sel2 des
multiplexeurs, et la fonction logique réalisée par les tables de correspondance (LUTs). (4 points)
Solution
a.

b. la période minimale
B1-AND3-OR1-B3->periode = 2+2+3+1 = 8 ns
c.
INF3500-final H2009 – Question 1.a
Nom : Matricule :
INF3500-final H2009 – Question 4.c
Nom : Matricule :
Diagramme d’états de l’unité de contrôle à modifier

Nom : Matricule :
Examen final
19 août 2009
Durée: 2h30.
Pondération: 40%.
tion est indiquée.
Les pages réponses à remplir et à remettre sont à la fin de l’énoncé. N’oubliez pas de préciser votre nom
et numéro de matricule sur chacune des pages réponse.
Nous désirons concevoir un processeur à but spécifique qui gère une machine à café. L’entité du gestion-
naire de la machine à café est comme suit :
entity gest_machine_a_cafe is
generic (
prix_cafe1 : positive;
prix_cafe2 : positive
);
port (
clk : in std_logic;
piece_introduite : in unsigned(6 downto 0);
piece_introduite_valide : in std_logic;
choix_cafe : in std_logic;
fermer_entree_piece : out std_logic;
annuler : in std_logic;
servir_cafe : out std_logic;
cafe_servi : in std_logic;
piece_a_rendre : out unsigned(6 downto 0);
piece_a_rendre_valide : out std_logic
);
end gest_machine_a_cafe;
Le client a le choix entre café1 (choix_cafe = ‘0’) ou café2 (choix_cafe = ‘1’). Les prix des cafés sont des
paramétres génériques : prix_cafe1 et prix_cafe2.
La partie mécanique de la machine à café comprend la fente dans laquelle le client introduit des pièces, la
sortie par laquelle les pièces de la monnaie sont rendues et la structure qui sert les cafés. Ces parties mé-
caniques envoient et/ou recoivent des requêtes au gestionnaire. Ce dernier attend que le client fasse son
choix et qu’il glisse des pièces dans la fente jusqu’à ce que le total des pièces introduites soit supérieur ou
égal au montant du café à servir. Lorsque ce montant est atteint alors un ordre sera émis à la partie méca-
nique pourque le café soit servi (servir_cafe = ‘1’. Ensuite, le gestionnaire calculera le montant de la
monnaie à rendre.
La machine ne peut recevoir ou retourner que des pièces de 1$, 25 cents, 10 cents ou 5 cents.
Le montant de la piece introduite est en cents donc lorsqu’une pièce de 1$ est introduite l’entrée pie-
ce_introduite sera égale à 100.
Pour éviter de considérer la même pièce plusieurs fois, le gestionnaire devra attendre que le signal piè-
ce_introduite_valide transite de ‘0’ à ‘1’ avant de considérer la nouvelle pièce.
Après avoir reçu l’avis que le café est servi (cafe_servi = ‘1’), le gestionnaire procédera à la remise de la
monnaie. Par rapport au montant introduit, le gestionnaire devra émettre des requêtes de remise de pièces.
Donc, par exemple, si le gestionnaire doit remettre 35 cents, il devra émettre l’ordre de remettre une pièce
de 25 cents puis d’une de 10 cents. Les ordres de remise de pièce doit être séparée à savoir que le port
piece_a_rendre_valide doit transiter de ‘1’ à ‘0’, pour que le second ordre soit considéré.
Pendant que les pièces sont entrées, le client peut décider d’annuler sa commande. Dans ce cas, le port
annuler sera égal à ‘1’ et le gestionnaire devra émettre les ordres de remise de pièces afin de rendre au
client le montant de pièces qu’il avait introduit avant l’annulation.
Pour éviter que le client introduise des pièces pendant que le café est servi ou que la monnaie est remise,
la fente des pièces entrées doit est fermée (fermer_entree_piece = ‘1’).
Les interfaces du gestionnaire de la machine à café se décrivent comme suit :
Port Description
reset Il réintialise les ports et bascules internes du gestionnaire.
clk L’horloge du processeur.
piece_introduite Le montant de la pièce introduite en cents.
piece_introduite_valide La pièce introduite doit être considérée que lorsque ce port est égal à ‘1’. Ce port doit
transiter de ‘0’ à ‘1’ entre l’introduction de deux pièces.
choix_cafe Lorsque ce port a la valeur ‘0’ alors le prix à charger devra correspondre à
prix_cafe1 sinon c’est prix_cafe2 qui sera utilisé.
fermer_entree_piece Le gestionnaire doit mettre ce port à ‘1’ pour éviter que le client continue à intro-
duire des pièces pendant que le café est servi ou que la monnaie est remise. En atten-
dant que le client introduise une nouvelle pièce et que le montant d’un café soit in-
troduit, le gestionnaire mettra ce port à ‘0’.
annuler Lorsque ce port à la valeur ‘1’, cela signifie que le client veut annuler sa commande
et reprendre ses pièces. L’ordre d’annulation ne sera pas considéré pendant qu’un
café est servi ou que la monnaie est rendue.
servir_cafe Ce port est égal à ‘1’ lorsque le total des pièces introduites est supérieur ou égal au
montant du café à servir. Ce port sera égal à ‘1’ jusqu’à ce que le café soit servi
(cafe_servi=‘1’), ensuite il retombera à ‘0’.
égal a ‘1’.
égal à '0'.
cafe_servi Ce port est égal à ‘1’ pour signifier que le café a été servi au client. Le gestionnaire
devra remettre la monnaie du client s’il y a lieu.
piece_a_rendre Le montant de la pièce à rendre.
piece_a_rendre_valide Lorsque ce port est égal à ‘1’, la partie mécanique sortira la pièce équivalente au
montant sur le port “piece_a_rendre”.

b) Donner le diagramme de la machine à états de l’unité de contrôle. (4 points)
c) Donner le diagramme du chemin de données de votre circuit. (4 points)
Solution

decrementer_monnaie
accumuler_total
init_monnaie
total_atteint
annuler_int
monnaie
init_total
b. le diagramme de la machine à états de l’unité de contrôle
pie
c e_
int
rod
uit
e _v
ali
de
= ‘1’
an
nu
le
r=
’1
'
ca
fe
_s
er
vi
=’
1'
Question 2. Questions brèves (4.5 points)
a. Citez 4 technologies de logique programmable (1 point).

b. Citez 4 composantes (autres que les LUT, multiplexeurs et bascules) qu’on peut retrouver dans un
FPGA (1 points).
c. Énumérez 2 conditions d’opérations qui ont un impact sur le délai de propagation d’une composante
(0.5 point)
d. Quelle technique de génération de vecteurs de tests serait la plus appropriée pour tester une machine à
états? Expliquez pourquoi. (1 point)
e. Comparez les SRAM et les DRAM? (un avantage et un inconvénient). (1 point)
Solution
a. ROM, PLA, PAL, FPGA
b. CLB, arbre d’horloge, IOB port, block RAM, processeur, bloc DSP tel que des MAC, logique
d’interconnexion.
c. Temperature, tension d’alimentation, la charge menée par la composante.
d. Les circuits de machine à états devraient être vérifiés par des vecteurs exhaustifs afin de
s’assurer que tous les états de la machine ont un comportement attendu.
e. SRAM : vitesse d’accès plus rapide mais elles nécessitent plus de portes logiques
DRAM : elles nécessitent un rafraichissement périodique sinon les données seront perdues,
mais elles nécessitent moins de portes logiques.
Question 3. Circuit séquentiel (9 points)
Soit le circuit gestionnaire_feux dont l’entité est décrite comme suit. Ce contrôleur de feux gère la circu-
lation à une intersection de voies. Les voies sont illustrées par la figure suivante.
Route Secondaire
(RS)
senseur
Route Principale
(RP)
Route Principale
(RP)
Nord
Route Secondaire
Ouest Est
(RS)
Sud
À cette intersection, les voitures de la voie secondaire ne peuvent que tourner vers la gauche ou vers la
droite. Étant donné que le flôt de voitures venant du Nord de la voie secondaire est faible, un senseur a été
placé afin que le feu autorisant les voitures venant du Nord ne soit vert que lorsqu’au moins une voiture y
est présente (senseur=’1’).
Les voitures de la voie principale circuleront lorsque leurs feux seront vert ou jaune. Ces derniers ne peu-
vent circuler que d’Est en Ouest.
L’entité du gestionnaire de feux gest_feux est décrite comme suit :
entity gest_feux is
generic (
);
port (
clk : in std_logic;
);
end gest_feux;
La machine à états qui décrit le comportement du gestionnaire de feux est comme suit :

Donnez le code VHDL de l’architecture de la machine à états du gestionnaire de feux

gest_feux. Le reset du circuit est asynchrone.
En sachant que les valeurs des feux sont énumérées comme suit :
• ROUGE = "100";
• VERT = "001";
• JAUNE = "010".
Solution
library ieee;
entity gest_feux is
generic (
);
port (
clk : in std_logic;
);
end gest_feux;
architecture beh of gest_feux is

type etat_t is (eteindrefeux, FRP_V, FRP_J, FSUD_V, FSUD_J, FNORD_V, FNORD_J);
signal etat : etat_t;
signal compteur : integer;
begin -- beh
begin -- process
if reset = ‘1’ then -- asynchronous reset (active low)
FRP <= "000";
FSud <= "000";
FNord <= "000";
elsif clk'event and clk = ‘1’ then -- rising clock edge
FRP <= "000";
FSud <= "000";
FNord <= "000";
-- le compteur sera reinitialise lors de la transition entre 2 etats

case etat is
when eteindrefeux =>
etat <= FRP_V;
-- feux de la route principale sont vert
when FRP_V =>
FRP <= "001";
FSUD <= "100";
FNord <= "100";
etat <= FRP_J;

end if;
-- feux de la route principale sont jaune
when FRP_J =>
FRP <= "010";
FSUD <= "100";
FNord <= "100";
if senseur = ‘1’ then
etat <= FNORD_V;
else
etat <= FSUD_V;
end if;
end if;
-- feu des voitures venant du sud est vert
when FSUD_V =>
FRP <= "100";
FSUD <= "001";
FNord <= "100";
etat <= FSUD_J;
compteur <= Duree_Jaune-1;
end if;
-- feu des voitures venant du sud est jaune
when FSUD_J =>
FRP <= "100";
FSUD <= "010";
FNord <= "100";
etat <= FRP_V;
end if;
-- feu des voitures venant du nord est vert
when FNORD_V =>
FRP <= "100";
FSUD <= "100";
FNord <= "001";
etat <= FNORD_J;
end if;
-- feu des voitures venant du nord est jaune
when FNORD_J =>
FRP <= "100";
FSUD <= "100";
FNord <= "010";
etat <= FSUD_V;
end if;
when others =>
end case;
end if;
end process;
end beh;
Question 4. Processeur à but général (7 points)
Soit le processeur à but général présenté dans les notes de cours au chapitre 8.
On désire ajouter une seconde mémoire de données dans l’architecture du processeur. Cette mémoire sera
une mémoire de 1024 cases contenant des mots de 16 bits. L’adresse d’un mot à lire ou à écrire d’une des
mémoire de données sera maintenant contenue sur 11 bits en sachant que le bit 10 de l’adresse précise
quelle mémoire de données est concernée par l’accès. Quand le bit est égal à ‘0’ l’accès concerne la mé-
moire de données initiale, sinon l’accès concerne la seconde mémoire (bit 10 = ‘1’). Les bits 9 à 0 préci-
sent la case à accéder selon la mémoire sélectionnée.
Nous rappelons que le registre d’instructions comporte 16 bits dont 4 bits alloués au code de l’instruction,
4 bits pour l’adresse du registre dans lequel la donnée sera lue ou écrite.
a. Donner le nouveau diagramme du chemin de données et préciser les composantes à rajouter

ou à modifier. (3 points)
b. Décrivez les nouveaux signaux ou les modifications effectuées sur certains signaux
du chemin de données. (1 points).
c. Quel sera l’impact de la nouvelle taille d’une adresse de mémoire de données sur l’unité de
contrôle du processeur? Modifiez le diagramme de la machine à états. (3 points)
Détachez et remettez la page réponse de la question 4.c avec votre cahier d’examen.
À titre d’exemple, le diagramme initial du chemin de données du processeur à but général au chapitre 8
des notes de cours est présenté ci-après.
Solution
a.
b. 2 signaux ont été rajoutés :

selmem : sélectionne la donnée qui devra être écrite dans un registre.
lecture/ecriture’2 : active la lecture ou l’écriture d’une donnée dans la seconde mémoire.
c. il faudra un cycle d’horloge de plus pour exécuter les instructions de chargement mémoire.
Question 5. Simulation et Synthèse (7.5 points)
D
AND2
C
B S1
AND1 B1
A AND3 OR1
F1
B2
AND4
XOR1
XOR2 F2
B3
S2
F3
B4 B5
En sachant que les portes ont les délais suivants :

- Les bascules ont un temps de préparation de 1 ns, un temps de maintien de 1 ns et un délai de propa-
gation de 2 ns.
- Les portes logiques ET et OU exclusif à 2 entrées ont un délai de propagation de 2 ns
- Les portes logiques OU et OU-exclusif à 3 entrées ont un délai de propagation de 3 ns.
a. En tenant compte des délais, compléter le chronogramme donné à la page suivante afin de fournir les
variations de S1, S2, F1, F2 et F3 jusqu’au temps t = 60 ns (Remettre la page du chronogramme avec
votre cahier d’examen) (2.5 points).
b. Donnez la période minimale du circuit. Explicitez vos calculs. (1 point)
c. Soit le bloc de logique programmable (CLB) suivant :
Sel1=
IN0
0
4 LUT F1
16x1 1
Sel2=
0
4 LUT F2
16x1 1
IN9
GND VCC
Dans ce dernier, on peut programmer 2 tables de conversion, 2 multiplexeurs. Les entrées IN0 à IN9,
GND et VCC peuvent être connectées à tous éléments du CLB. L’entrée GND permet de propager la va-
leur logique ‘0’ et l’entrée VCC la valeur ‘1’. Les sorties des tables de conversion ou celles des multi-
plexeurs peuvent être connectées à une des sorties F1 et F2.
Proposez un routage possible du circuit dans un FPGA. Vous pouvez instancier autant de CLB que
nécessaire. Montrez les connexions entre les CLB, la valeur des ports de sélection Sel1 et Sel2 des
multiplexeurs, et la fonction logique réalisée par les tables de correspondance (LUTs). (4 points)
Solution
a.

b. la période minimale
B1-AND3-OR1-B3->periode = 2+2+3+1 = 8 ns
c.
Nom : Matricule :
INF3500-final H2009 – Question 4.c
Nom : Matricule :

Nom : Matricule :
Examen intra
17 Juin 2009
Durée: 2h.
Pondération: 20%.
Documentation: Une feuille recto-verso 8.5”×11” ou A4 permise.
tion est indiquée.
Question 1. (5 points)-exercice sur la synthèse
Soit le code VHDL suivant.
library ieee;
entity MAC is
generic (
W : positive := 4
);
port (
clk : in std_logic;
entree1 : in signed(W-1 downto 0);
sortie : out signed(2*W downto 0)
);
end MAC;
architecture beh of MAC is

begin -- beh
sortie <= (entree1 * entree2) + entree3;
end beh;
a - Donnez le diagramme du circuit MAC correspondant au code VHDL ci-avant. Indiquez la largeur en
bits des ports et des signaux intermédiaires en sachant que W est égal à 4. Vous pouvez utiliser des opéra-
tions logiques et arithmétiques, la comparaison, des multiplexeurs, décodeurs et encodeurs, éléments mé-
moire, etc.
b – Donnez le diagramme du circuit itératif combinatoire à 3 étages qui cascade 3 MAC en sachant que le
port entree3 du premier étage de MAC prendra la valeur zéro. En sachant que le port entree3 du prochain
étage prendra la valeur du port sortie du module de l’étage précédent.
c – Donnez le diagramme du circuit itératif séquentiel de 3 étages qui cascade 3 MAC. En sachant que le
port entree3 du premier étage de MAC sera prendra la valeur zéro.
Solution
a)
b)
c)
Soit un circuit d’un gestionnaire de réservoir d’essence de voiture niveau_réservoir. Deux jeux
de senseurs sont positionnés aux deux niveaux du réservoir comme illustré par la Figure 1. Ces
senseurs sont placés dans le réservoir. Ils donnent une valeur logique quand ils baignent dans
l'essence, et une valeur 0 autrement. Ces signaux permettent de calculer le niveau d'essence du
réservoir. Le niveau d’essence est calculé comme suit :
• Si les senseurs du niveau_H sont égaux et leurs valeurs sont différentes de zéro alors le niveau de
sortie niv_out prendra la valeur de niv_S2_A.
• Dans le cas contraire, le niveau de sortie niv_out sera égal à la valeur de niv_S1_A si les valeurs
de niv_S1_A et niv_S1_B sont égales, sinon niv_out prendra la valeur zéro.
Figure1. Exemple du positionnement des senseurs Figure 2. Interfaces du réservoir

dans le réservoir.
Les ports de l’entité niveau_réservoir sont décrits comme suit :

• Les entrées niv_S2_A et niv_S2_B donnent la valeur du niveau supérieur.
• Les entrées niv_S1_A et niv_S1_B donnent la valeur du niveau inférieur.
• Le port de sortie niv_out aura la valeur niv_S2_A si le niveau supérieur est actif à savoir que
niv_S2_A et niv_S2_B sont égaux et que leur valeur est différente de zéro. Niv_out prendra la va-
leur de niv_S1_A dans le cas contraire et seulement si niv_S1_A et niv_S1_B sont égaux sinon
niv_out aura la valeur zéro.
• Le port de sortie erreur sera activé si niv_S2_A et niv_S2_B ont des valeurs différentes OU si
niv_S1_A et niv_S1_B ont des valeurs différentes.
Le port erreur est un std_logic alors que les ports, niv_s2_B, niv_S1_A, niv_S1_A et niv_out sont des vec-
teurs de N bits non-signés (unsigned).
Donnez l’entité et l’architecture synthétisable de niveau_réservoir.
Solution
library ieee;
entity niveau_reservoir is
generic (
N : positive);
port (
niv_S1_A : in unsigned(N-1 downto 0);
niv_S1_B : in unsigned(N-1 downto 0);
niv_S2_A : in unsigned(N-1 downto 0);

niv_S2_B : in unsigned(N-1 downto 0);
niv_out : out unsigned(N-1 downto 0);
);
end niveau_reservoir;
architecture beh of niveau_reservoir is
begin -- beh
process (niv_S1_A, niv_S1_B, niv_S2_A, niv_S2_B)

begin -- process
if niv_S2_A /= to_unsigned(0, N) and niv_S2_A = niv_S2_B then
niv_out <= niv_S2_A ;
elsif niv_S1_A = niv_S1_B then
niv_out <= niv_S1_A ;
else
niv_out <= (others => '0');
end if;
erreur <= '0';

if niv_S2_A /= niv_S2_B or niv_S1_A /= niv_S1_B then
erreur <= '1';
end if;
end process;
end beh;
Donnez le diagramme d'états correspondant au code VHDL suivant. Identifiez clairement les états, les
transitions entre états et les conditions correspondantes, et la valeur des signaux de sortie.
library IEEE;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
entity exo4 is
generic (
PAUSETIME: INTEGER := 100 );
port (
CLK: in STD_LOGIC;
fifo_rx_full: in STD_LOGIC;
reset: in STD_LOGIC;
fifo_rd_en: out STD_LOGIC;
stop_rx: out STD_LOGIC);
end exo4;
architecture fsm of exo4 is
-- diagram signals declarations

signal PauseCompteur: INTEGER range PAUSETIME-1 downto 0;
-- SYMBOLIC ENCODED state machine: Sreg0

type Sreg0_type is (
Attente, RX_mode, Pause, Transiter
);
-- attribute enum_encoding of Sreg0_type: type is ... -- enum_encoding attrib-
ute is not supported for symbolic encoding
signal Sreg0: Sreg0_type;
begin
----------------------------------------------------------------------
-- Machine: Sreg0
----------------------------------------------------------------------
Sreg0_machine: process (CLK, reset)
begin
if reset='1' then
Sreg0 <= Attente;
-- Set default values for outputs, signals and variables
PauseCompteur <= PAUSETIME;
elsif CLK'event and CLK = '1' then
-- Set default values for outputs, signals and variables
PauseCompteur <= PAUSETIME;
case Sreg0 is
when Attente => -- transition d'un cycle apres le re-
set
Sreg0 <= RX_mode;
when RX_mode => -- mode de reception normal
-- -- rentrer en mode pause lorsque la fifo de reception est
pleine
if fifo_rx_full = '1' then
Sreg0 <= Pause;
end if;
when Pause => -- attendre la fin de la pause
PauseCompteur <= PauseCompteur -1;
if PauseCompteur=0 then
Sreg0 <= Transiter;
end if;
when Transiter => -- -- si la fifode reception
est toujours pleine, lancer une autre pause
if fifo_rx_full = '1' then
Sreg0 <= Pause;
else
Sreg0 <= RX_mode;
end if;
--vhdl_cover_off
when others =>
null;
--vhdl_cover_on
end case;
end if;
end process;
-- signal assignment statements for combinatorial outputs

fifo_rd_en_assignment:
fifo_rd_en <= '0' when (Sreg0 = Attente) else
'1';
stop_rx_assignment:
stop_rx <= '0' when (Sreg0 = Attente) else
'1' when (Sreg0 = Pause) else
'1' when (Sreg0 = Transiter) else
'0';
end fsm;
Solution
Une imprimante couleur reçoit, pour chaque point de la feuille à imprimer, un triplet (R, V,
B) pour l'intensité de couleur en rouge, vert et bleu, respectivement. Les intensités sont ex-
primées en nombres non signés sur 8 bits, de 0 à 255. L'imprimante utilise trois cartouches:
une cyan, une magenta et une jaune. Les équations de conversion de RVB à CMJ sont don-
nées par C = 255- R; M = 255-V; Y = 255- B.
a. Donnez le diagramme d'un circuit numérique combinatoire qui convertit des coordonnées
RVB à CMJ. Vous pouvez utiliser des opérations logiques et arithmétiques, la comparai-
son, des multiplexeurs, décodeurs et encodeurs, éléments mémoire, etc.
Pour économiser l'encre de couleur, les imprimantes utilisent habituellement une quatrième
cartouche, noire celle-là. On enlève des coordonnées CMJ la valeur la plus petite d'entre el-
les, et cette valeur donne l'intensité du noir à utiliser. Par exemple, des valeurs RVB de (5,
55, 55) correspondent à des valeurs CMJ de (250, 200, 200). Ces coordonnées correspondent
à (200, 200, 200) + (50, 0, 0). L'imprimante peut donc utiliser une intensité de 200 pour le
noir et 50 pour le cyan, sans utiliser ni le magenta ni le jaune.
b. Donnez le diagramme d'un circuit numérique combinatoire qui convertit des coordonnées
CMJ à NCMJ (où N correspond au noir). Vous pouvez utiliser des opérations logiques et
arithmétiques, la comparaison, des multiplexeurs, décodeurs et encodeurs, éléments mé-
moire, etc.
Solution
255 +
C
R -
255 +
M
V -
255 +
J
B -
a)
<
Cin 0
<
Min 1
0
N
Jin 1
Cin +
Cin C
-
Min +
M
-
Jin +
Jin J
-
b)
Soit l'entité module1 ainsi que le banc d'essai module1_tb permettant de le vérifier. Les codes VHDL de
ces modules sont comme suit:
library ieee; library ieee;
use ieee.std_logic_1164.all; use ieee.std_logic_1164.all;
entity circuit1 is
port (
clk : in std_logic; entity circuit1_tb is
x1 : in std_logic;
x2 : in std_logic; end circuit1_tb;
x3 : in std_logic;
y1 : out std_logic; architecture beh of circuit1_tb is
y2 : out std_logic component circuit1
); port (
end circuit1; clk : in std_logic;
x1 : in std_logic;
architecture beh of circuit1 is x2 : in std_logic;
signal p1 : std_logic; x3 : in std_logic;
signal p2 : std_logic; y1 : out std_logic;

signal p3 : std_logic; y2 : out std_logic
begin -- beh );
end component;
p1 <= x1 and x2 and not x3;
p2 <= not x1 and x2 and x3; signal vecteur_test : std_logic_vector(2
p3 <= not x1 and not x2; downto 0);
signal y1 : std_logic;
process (clk) signal y2 : std_logic;
begin -- process
if clk'event and clk = '1' then begin -- beh
y1 <= p1 or p2; UUT : circuit1
end if; PORT MAP(vecteur_test(0), vecteur_test(2),
end process; vecteur_test(1), y1, y2);
y2 <= p3; process

end beh; begin -- process
for i in 3 to 7 loop
vecteur_test <=
std_logic_vector(to_unsigned(i, vec-
teur_test'length));
wait for 10 ns;
assert (y1='1' and y1 /= y2)
report "Erreur y1 and y2 ne peuvent pas
actif en meme temps" severity error;
end loop;
report "Fin simulation" severity failure;
end process;
end beh;
a- Indiquez quelle technique de vérification a été appliquée.

b- Donnez le chronogramme des ports x1, x2, x3, y1 et y2 ainsi que ceux des signaux internes p1, p2 et
p3 durant la simulation.
c - Précisez tous les textes qui pourraient être affichés durant la simulation.
d – Indiquez à quel temps t la simulation se terminera.
Remplissez le gabarit de la page suivante. N’oubliez pas de remettre la page dans votre cahier d’examen.
Nom :
Matricule :
clk
x1
x2
x3
p1
p2
y1
y2
0 ns 10 ns 20 ns 30 ns 40 ns 50 ns
Solution
Examen final
23 avril 2009
Durée: 2h30.
Pondération: 40%.
Documentation: Une feuille recto verso 8.5”×11” ou A4 manuscrite permise.
tion est indiquée.
INF3500 – examen final – 23 avril 2009
Dans les applications de traitement de signaux, une opération typique consiste à trouver la somme des
produits entre un signal d’entrée et celle d’un tableau de constantes tel que :
i = N −1
Re sultat = Entreei × Coefi
i =0
Voici l’entité du processeur à but spécifique que vous devez concevoir.
library IEEE;
entity sommeproduit is
generic (
W : positive;
M : positive := 8);
port (
entree : in unsigned(W - 1 downto 0);
go : in std_logic;
entreevalide : in std_logic;
sortievalide : out std_logic;
erreur : out std_logic;
sortie : out unsigned(W - 1 downto 0)
);
end sommeproduit;
Le paramètre générique W spécifie le nombre de bits des ports entree et sortie.

Le paramètre M correspond au nombre maximal de sommes de produits. Il est égale à 8.
Les ports du circuit sont décrits comme suit :

Nom Description
Reset Réinitialise le circuit.
CLK L’horloge du système.
Go Il est activé durant un coup d’horloge pour signifier le début des calculs.
Entreevalide Il est activé en même temps que go, mais il reste actif à ‘1’ durant l’envoi des entrées.
En sachant que M données peuvent être envoyées au maximum, ainsi le nombre de do-
néées envoyées sera compris entre 1 et M.
Sortievalide Ce port est activé durant un coup d’horloge pour signifier la fin des calculs et que la
valeur sur le port sortie peut être lue.
Erreur Le circuit ne peut calculer qu’une somme de M produits. Si le nombre d’entrées en-
voyées est supérieur à M, alors ce port sera activé pour indiquer qu’une erreur est surve-
nue durant le calcul.
Sortie La somme des produits.
Le processeur à but spécifique effectuera la somme des produits en sachant que le processeur reproduira
l’algorithme suivant :
TantQue (TRUE)
Attendre go;
sortie = 0;
i = 0;
TantQue (entreevalide=’1’ ET i<M)
Sortie = sortie + (entree x coef[i]);
i++;
Fin TantQue
Si entreevalide=’1’ ET i== M Alors
erreur = 1
sortievalide = 0
Sinon
erreur = 0
sortievalide = 1
Fin Si
Fin TantQUE

b) Donner le diagramme de la machine à états de l’unité de contrôle ainsi que le code VHDL de cet-
te dernière. (6 points)
c) Donner le diagramme du chemin de données de votre circuit en sachant que la table des coeffi-
cients contient 8 cases. (4 points)
Solution
b. la machine à états
Code VHDL complet du processeur à but spécifique:

library IEEE;
entity sommeproduit is
generic (
W : positive);
port (
CLK : in std_logic;
go : in std_logic;
entreevalide : in std_logic;
entree : in unsigned(W-1 downto 0);
sortievalide : out std_logic;
erreur : out std_logic;
sortie : out unsigned(w-1 downto 0));
end sommeproduit;
architecture beg of sommeproduit is
type state_t is (INIT, CALCUL, ER, FIN);

signal cur_state : state_t;
signal entree_t : unsigned(w-1 downto 0);
signal charge_somme : std_logic;
signal sommeprod : unsigned(W-1 downto 0);
type coef_t is array (integer range <>) of unsigned(W-1 downto 0) ;
constant coef : coef_t (0 to 7) := (X"01", X"02", x"03", x"04", x"05", x"06", x"07", x"08");
signal i : integer range 8 downto 0;
begin -- beg
unite_controle: process (CLK, reset)

begin -- process unite_controle
if reset = '
1'then -- asynchronous reset (active low)
cur_state <= INIT;
charge_somme <= ' 0'
;
i <= 0;
sortievalide <= '
0';
erreur <= '0';
elsif CLK' event and CLK = '

1'then -- rising clock edge
;
sortievalide <= '0'
;
erreur <= '0';
case cur_state is
when INIT =>
cur_state <= INIT;
i <= 0;
if (go = '1') then
cur_state <= CALCUL;
end if;
when CALCUL =>
if (i>=7) AND entreevalide ='1'then
cur_state <= ER;
elsif entreevalide=' 0'then
cur_state <= FIN;
else
cur_state <= CALCUL;
;
i <= i + 1;
end if;
when ER =>
cur_state <= INIT;
erreur <= ' 1'
;
when FIN =>
cur_state <= INIT;
sortievalide <= '1';
when others =>
cur_state <= INIT;
i <= 0;
end case;
end if;
end process unite_controle;
chemin_donnees: process (CLK, reset)

begin -- process chemin_donnees
if reset = '
1'then -- asynchronous reset (active low)
sommeprod <= (others=>' 0'

);
entree_t <=(others=>'0' );
sortie <= (others=>'0'
);
elsif CLK'event and CLK = ' 1'then -- rising clock edge
entree_t <= entree;
if charge_somme = ' 0'then
sommeprod <= resize(entree_t * coef(i), 8);
else
sommeprod <= resize(sommeprod + (entree_t * coef(i)), 8);
end if;
sortie <= sommeprod;
end if;
end process chemin_donnees;
end beg;
Question 2. (8 points)- Processeur à but général
Soit le processeur à but général présenté dans les notes de cours au chapitre 8. Nous désirons rajouter une
instruction dans le jeu d’instructions de ce processeur. Cette nouvelle instruction effectue l’opération
MAC-multiply and accumulate qui multiplie deux opérandes (Opin1 x Opin2) et le résultat de la multipli-
cation est additionné à une troisième opérande (Opinout). Le résultat est ensuite écrit dans l’opérande
Opinout.
Le code de l’instruction est sur 4 bits. Les opérandes Opinout et Opin1 donnent l’adresse de deux regis-
tres. L’adresse des registres est codée sur 4 bits. Opin2 correspond à une valeur constante qui est contenue
sur 16 bits. Donc, l’instruction doit effectuer :
Opinout = Opinout + (Opin1 x Opin2)
a. Modifiez le diagramme du chemin de données du processeur. (3 points)

b. Modifiez le diagramme de la machine à états de l’unité de contrôle du processeur. N’oublier
pas de préciser les valeurs des signaux de contrôle qui sont affectés par vos modifications. (3.5
points)
c. Donnez la liste et une brève description du/des signal/signaux signaux que vous rajoutez au
processeur. Précisez aussi les modifications effectuées sur certains signaux existants de
l’architecture. (1.5 point).
Détachez et remettez la page réponse dans votre cahier d’examen.
Solution
a. Diagramme du chemin de données
!
b. Diagramme d’états
"#
$ "
% %
" &'(%
,# - -"-. )
,# ) % %
,# + %
,# "# - -"-.
)
* + % / 0
12
c. La liste des signaux modifiés ou rajoutés

- choixSource : sa taille sera maintenant égale à 3 bits
- MACres : il conduit le résultat de la multiplcation-addition
- constante : sa taille est maintenant égale à 16 bits.
d.
INF3500-final H2009 – Question 2

Nom : Matricule :
Diagramme du chemin des données d’un processeur à usage général
Question 3. (6 points) – Circuit séquentiel
Concevez une pile de type LIFO (last in first out). Cette pile stocke des données et celles-ci seront dans
l’ordre inverse de leur écriture à savoir que la dernière donnée écrite sera la première donnée lue.
La déclaration de l'
entité de la LIFO est définie comme suit :
library ieee;
entity lifo is
generic (
N : positive := 4
W : positive := 8
);
port (
clk : in std_logic;
din : in std_logic_vector(W - 1 downto 0);
dout : out std_logic_vector(W - 1 downto 0);
wr_en : in std_logic;
rd_en : in std_logic
empty : out std_logic;
full : out std_logic
);
end fifo;
Les paramètres N et W représentent respectivement le nombre maximum d'

éléments dans la pile
et la largeur des données en bits.
Les ports de l’entité se décrivent comme suit :

• Le signal clk est un signal d' horloge synchronisant toutes les activités de la pile. Le si-
gnal reset permet de vider la pile.
• Les ports din et dout sont respectivement l' entrée et la sortie de la pile.
• Les ports empty et full indiquent respectivement que la pile est vide ou bien qu' elle est
pleine.
• Quand le signal wr_en (write enable) est activé, la valeur placée sur le port din sera insé-
rée dans la pile lors de la prochaine transition active du signal d'horloge clk.
• Quand le signal rd_en (read enable) est activé, la valeur insérée le plus récemment sur la
pile sera écrite sur le port dout lors de la prochaine transition active du signal d' horloge clk.
• Il doit être possible d' écrire une nouvelle valeur dans la pile et de lire la valeur la plus ré-
cente simultanément.
• Lorsque la LIFO est pleine les requêtes d’écriture doivent être ignorées et lorsque la LI-
FO est vide les opérations de lecture doivent être ignorées.
Donnez le code VHDL de l’architecture de la LIFO.
Solution
library ieee;
entity lifo is
generic (
N : positive := 4; -- la profondeur (le nombre d' éléments) dans la pile
W : positive := 8 -- la largeur (en bits) de la pile
);
port (
clk : in std_logic;
reset : in std_logic; -- actif haut: un ' 1'réinitialise la pile
din : in std_logic_vector(W - 1 downto 0); -- données entrant dans la pile
dout : out std_logic_vector(W - 1 downto 0); -- données sortant de la pile
wr_en : in std_logic; -- write-enable: si actif, une donnée sera lue de din et
-- entrée dans la pile au prochain front montant de clk
rd_en : in std_logic; -- read-enable: si actif, une donnée sera sortie de la pile
-- et placée sur dout au prochain front montant de clk
empty : out std_logic; -- indique que la file est vide
full : out std_logic -- indique que la file est pleine
);
end lifo;
architecture tache of lifo is

type List is array (NATURAL range <>) of std_logic_vector(W - 1 downto 0);
signal FIFOList : List(N - 1 downto 0);
signal writeptr : integer range 0 to N-1 := 0;
signal plein : std_logic ;

signal vide : std_logic;
begin
process(clk, reset) -- Intervient au coup d' horloge
variable nb_elem : integer range N-1 downto 0;
begin
if reset =' 1'then
writeptr <= 0;
vide <= ' 1';
plein <= ' 0' ;
dout <= (others => ' 0');
if rd_en = ' 1'and vide = '
0'then --Mode Lecture (rd et pas vide)
dout <= FIFOList(writeptr-1); --lit à la position du pointeur
plein <= ' 0' ;
nb_elem := nb_elem -1;
if nb_elem = 0 then
vide <= ' 1' ; --liste vide si les 2 pointeurs sont égaux après lecture
end if;
end if;
if wr_en = '
1'and plein = '
0'then --Mode écriture (wr et pas plein)
FIFOList(writeptr) <= din; --écrit à la position du pointeur

nb_elem := nb_elem + 1;
if writeptr >= N - 1 then

writeptr <= 0;
else
writeptr <= writeptr + 1; --déplace le pointeur
end if;
vide <= ' 0';
if(nb_elem = N) then
plein <= '1';
end if;
end if;
end if;
end process;
empty <= vide;

full <= plein;
end tache;
Question 4. (4 points) – circuit combinatoire
Soit, le circuit d’un décaleur de bits vers la gauche shift_Nbits. Le circuit comprend :
• un port d’entrée de 4 bits input de type unsigned.
• un port de contrôle de 2 bits shift qui indique combien de décalages doivent être effectués. Ce
port est de type std_logic_vector.
• un port de sortie de 4 bits output de type unsigned.
Par exemple :
Si le port input est égal à “1010” et shift est égal à “10” alors output sera égal à “1000”.
Donnez le diagramme du circuit d’un décaleur vers la gauche de 4 bits. Vous pouvez utiliser des opéra-
tions logiques et arithmétiques, la comparaison, des multiplexeurs, décodeurs et encodeurs, éléments mé-
moire, etc. Vous ne pouvez pas utiliser l’opération shift.
Première Solution
Deuxième Solution (fonctionne, mais nécessite plus de ressources)
Table de vérité du décodeur :

Shift D3 D2 D1 D0
00 1 1 1 1
01 1 1 1 0
10 1 1 0 0
11 0 0 0 0
*** Pour illustration seulement (pas demandé dans la question) ***

Code VHDL, deux solutions proposées ainsi que le banc d’essai
library IEEE;
entity shifter is
port (
shift : in std_logic_vector(1 downto 0);
input : in unsigned(3 downto 0);
output : out unsigned(3 downto 0));
end shifter;
architecture beh1 of shifter is

begin -- beh
process (shift, input)
variable sortie_t : unsigned(3 downto 0);
begin -- process
sortie_t := input;
if (i=to_integer(unsigned(shift))) then
exit;
end if;
sortie_t := sortie_t SLL 1;
end loop; -- i
output <= sortie_t;

end process;
end beh1;
architecture beh2 of shifter is

begin -- beh
output <= input sll to_integer(unsigned(shift));
end beh2;
library IEEE;
entity shifter_tb is
end shifter_tb;
architecture beh1 of shifter_tb is

component shifter
port (
shift : in std_logic_vector(1 downto 0);

input : in unsigned(3 downto 0);
output : out unsigned(3 downto 0));
end component;
signal shift : std_logic_vector(1 downto 0);
signal input : unsigned(3 downto 0);
signal output : unsigned(3 downto 0);
begin -- beh
uut : shifter
port map (
shift, input, output);
input <= X"1";

process
begin -- process
shift <= std_logic_vector(to_unsigned(i,2));
wait for 10 ns;
end loop; -- i
end process;
end beh1;
Question 5. (6 points) – questions brèves
a. Rappelez les différentes phases du flot de conception qui mènent au déploiement d’un circuit sur un
FPGA. Indiquez quelle est la phase la plus importante du flot et expliquez pourquoi. (1.5 points)
b. Énumérez les méthodes de vérification et pour chaque méthode citez un type d’application approprié à
l’utilisation de la méthode. (2 points)
c. Donnez les différentes causes de déphasage d’horloge d’un circuit. (1.5 points)
e. Énumérez quatre considérations d’implémentation dont il faut tenir compte durant la conception d’un
circuit numérique. (1 point)
Solution
a. conception et génération du code HDL, vérification, synthèse, implémentation, génération du
fichier de configuration.
La vérification est la phase la plus importante du processus de conception. Cette dernière garantit
que la fonctionnalité du circuit est respectée et c’est l’objectif primaire à atteindre avant de pas-
ser aux étapes de synthèse et d’implémentation.
b. Méthodes de vérification
- par tableaux de constantes : quand le nombre de valeurs à tester est limité et doit être fixe.
- aléatoire : algorithmes mathématiques, conversion de type pouce à mètre par exemple.
- fichiers : pour des applications de traitement d’images.
- exhaustive : des machines à états
c.
• un mauvais routage du signal d’horloge avec des chemins de longueur différente;
• un mauvais routage du signal d’horloge avec un débalancement de la charge du signal; et,
• l’introduction de signaux de contrôle du signal d’horloge avec de la logique combinatoire
(clock gating).
e. les considérations d’implémentation :

• Précision des calculs
• Puissance consommée
• Taille du système (en nombre de portes logiques ou transistors par exemple)
• Taux de traitement (nombre d’opérations traités par unité de temps)
Question 6. (4 points) – Implémentation avec la technologie PAL
Soit le code VHDL suivant :

library ieee;
entity question4 is
port (
clk : in std_logic;
x1 : in std_logic;
x2 : in std_logic;
x3 : in std_logic;
y1 : out std_logic;
y2 : out std_logic;
);
end question4;
architecture beh of question4 is

signal p1 : std_logic;
begin -- beh
p1 <= x1 and x2 and not x3;

p2 <= not x1 and x2 and x3;
p3 <= not x1 and not x2;
p4 <= x1 and not x2 and not x3;
process (clk, <reset name>)

begin -- process
if clk'
event and clk = '
1'then -- rising clock edge
y1 <= p1 or p2;
end if;
end process;
y2 <= p3 or p4;
end beh;
Complétez le circuit PAL suivant qui implémentera la fonctionnalité décrite dans le code VHDL du cir-
cuit question4. N’oubliez pas de définir la valeur des signaux de programmation des multiplexeurs (se-
lect1 et select2).
Détachez et remettez la page réponse dans votre cahier d’examen.
Ce circuit PAL comporte des bascules qui peuvent être utilisées selon la valeur du signal de contrôle du
multiplexeur. Si le signal select est égal à ‘1’ alors la valeur de Q sera conduite sur la sortie du multi-
plexeur. Sinon la sortie du OR sera multiplexée sur la sortie du multiplexeur.
INF3500-final H2009 – Question 6

Nom : Matricule :
Solution
Examen intra
24 février 2009
Durée: 2h.
Pondération: 20%.
tion est indiquée.
Question 1. (4 points)-exercice sur la synthèse
Donnez le diagramme du circuit correspondant au code VHDL suivant. Indiquez la largeur en bits des
ports et des signaux en sachant que N est égal à 2. Vous pouvez utiliser des opérations logiques et arith-
métiques, la comparaison, des multiplexeurs, décodeurs et encodeurs, éléments mémoire, etc.
library ieee;
entity entite1 is
generic (N : positive)
port(
clk : in std_logic;
A : in std_logic_vector(n - 1 downto 0);
B : in std_logic_vector(n - 1 downto 0);
C: in std_logic;
sortie : out std_logic(2 downto 0)
);
end entite1;
architecture comportementale of entite1 is

signal sig1: std_logic_vector(2 downto 0);
begin
process(A)
begin
sig1 <= (others => '0');
sig1(to_integer(unsigned(A))) <= '1';
sig2 <= (others => '0');
sig2(to_integer(unsigned(B))) <= '1';
end process;
process(clk, reset)
begin
if(reset='1') then
sortie <= (others => '0');
elsif (clk'event and clk='1') then
if (C = '0') then
sortie <= sig1;
else
sortie <= sig2;
end if;
end if;
end process;
Solution
2
A
decoder
3
0
sig1 3
3
3
sortie
1
2 sig2
B decoder
1
C clk reset
Soit un circuit de compteur de voitures compteur_autos destiné à la gestion de la circulation routière

d’une ville, dont le symbole est :
Les ports de l’entité compteur_autos sont décrits comme suit :

• Quand le port init est égal à ‘1’ le port compteur est remis à 0 et le port Er aussi est mis à ‘0’.
• À chaque fois que la valeur du port senseur passe de ‘0’ à ‘1’, compteur doit être incrémenté;
• Le port compteur correspond au nombre de voitures qui sont passées depuis la dernière initialisa-
tion;
• Le port Er est égal à ‘1’ quand il y a eu un débordement sur compteur. En effet, il y aura un dé-
bordement quand le port compteur atteint la valeur maximale qu’il peut contenir et une nouvelle
incrémentation est effectuée. Dans ce cas, l’incrémentation fera que la nouvelle valeur de comp-
teur sera égale à 0. Pour éviter qu’un employé lise une mauvaise valeur, le port Er lui permettra
de savoir qu’il doit ignorer la valeur de compteur Y. Le port Er restera égal à ‘1’ jusqu’à la pro-
chaine initialisation (int=’1’).
Les ports de 1 bit sont des std_logic alors que le port compteur est un vecteur de W bits non-signés (un-
signed).
Donnez l’entité et l’architecture synthétisable du compteur d’autos compteur_autos.
Solution
library ieee;
entity compteur_autos is
generic (
W : positive);
port (
init : in std_logic;
compteur : out unsigned(W-1 downto 0);
Er : out std_logic);
end compteur_autos;
architecture comportementale of compteur_autos is

signal sig_compteur : integer range 2**W-1 downto 0;
signal sig_Er : std_logic;
begin -- comportementale
compteur <= to_unsigned(sig_compteur, W);

Er <= sig_Er;
process (init, senseur)

begin -- process
if (init='1') then
sig_compteur <= 0;
sig_Er <= '0';
elsif (senseur’event and senseur = '1') then
sig_Er <= '0';
if (sig_Er = '1' or sig_compteur = 2**W-1) then

sig_Er <= '1';
end if;
sig_compteur <= sig_compteur + 1;

end if;
end process;
Soit le module majorite dont l’entité et l’architecture sont décrits comme suit :
library IEEE;
entity majorite is
port (
X: in std_logic_vector(7 downto 0);
F : out std_logic
);
end majorite;
architecture comportementale of majorite is

begin
process (I)
variable compte : integer := 0;
begin
compte := 0;
for k in W - 1 downto 0 loop
if I(k) = '1' then
compte := compte + 1;
end if;
end loop;
if (compte > W / 2) then
F <= '1';
else
F <= '0';
end if;
end process;
Écrivez en VHDL un banc d'essai qui teste le module majorité. Le banc d’essai doit générer aléatoire-
ment 10 vecteurs de test pour l’entrée X de l’unité à tester, en sachant que la valeur générée de X doit être
comprise entre 55 et 128. Les vecteurs seront générés à chaque 10 ns.
Rappel :
La procédure uniform(seed1, seed2, resultat) génère aléatoirement un nombre réel compris
entre 0.0 et 1.0. Cette procédure a trois paramètres: deux valeurs « graines » seed1 et seed2 pour gui-
der la génération de nombres pseudo-aléatoires, et le nombre pseudo-aléatoire retourné dans le paramètre
resultat. La procédure uniform est définie dans le package math_real.
Solution
library ieee;
entity majorite_tb is
end majorite_tb;
architecture arch of majorite_tb is

component majorite
port (
X : in unsigned(7 downto 0);
F : out std_logic) ;
end component;
signal X : unsigned(7 downto 0);

signal F : std_logic;
begin
-- instancier l'unitie a teste
UUT : majorite
port map (
X =>X, F => F);
process
variable t : integer := -1;
begin -- process
uniform(seed1, seed2, aleatoire); -- 0.0 < aleatoire < 1.0
aleatoire := 55.0 + floor(aleatoire * 73.0); -- 55.0 <= aleatoire <= 128.0
t := integer(aleatoire); -- 55 <= t <= 128
X <= to_unsigned(t, 8);
wait for 10 ns;

end loop; -- i
end process;
end arch;
Soit l'entité module1 ainsi que le banc d'essai module1_tb permettant de le vérifier. Les codes VHDL de
ces modules sont comme suit:
library ieee; library IEEE;
use ieee.std_logic_1164.all; use IEEE.std_logic_1164.all;
use ieee.numeric_std.all; entity module1TB is
end module1TB;
entity module1 is architecture arch of module1TB is
port ( component module1
A, B : in std_logic; port (
F : out std_logic A, B : in std_logic;
); F : out std_logic
end module1; );
architecture arch of module1 is end component;
signal S1, S2: std_logic; signal A,B,F : std_logic;

begin begin
S1 <= A and B; UUT : module1 port map (A, B, F);
S2 <= not(B); A <= '0' after 0 ns, '1' after 20 ns;
process (S1, S2) B <= '1' after 0 ns, '0' after 10 ns,
begin '1' after 15 ns;
F <= S1 xor S2; end arch;
end process;
end arch;
Donnez le chronogramme des ports A, B, F et des signaux internes S1 et S2 durant une simulation com-
prise entre les temps 0 ns jusqu’à 25 ns. Remplissez le gabarit de la page suivante. N’oubliez pas de re-
mettre la page dans votre cahier d’examen.
Nom :
Matricule :
Solution
Donnez le diagramme d'états correspondant au code VHDL suivant. Identifiez clairement les états, les
transitions entre états et les conditions correspondantes, et la valeur des signaux de sortie.
library ieee;
entity controleur is
port (
reset_n : in std_logic;
clk : in std_logic;
requete : in std_logic;
stop : in std_logic;
start : out std_logic;
continue : out std_logic);
end controleur;
architecture beh of controleur is

type type_etat is (S1, S2, S3, S4);
signal etat_courant : type_etat := S1;
signal etat_prochain : type_etat := S1;
begin -- beh
-- mise a jour de l'etat courant
begin -- process
if reset_n = '0' then -- asynchronous reset (active low)
etat_courant <= S1;
elsif clk'event and clk = '1' then -- rising clock edge
etat_courant <= etat_prochain;
end if;
end process;
-- mise aj our de l'etat prochain

process (etat_courant, requete, stop)
begin -- process
etat_prochain <= etat_courant;
when S1 =>
if requete='1' then
etat_prochain <= S2;
end if;
when S2 =>
when S3 =>
if stop='1' then
etat_prochain<= S1;
else
end if;
when S4 =>
if stop='1' then
etat_prochain<= S1;
elsif requete='1' then
else
end if;
when others => null;
end case;
end process;
-- mise a jour des sorties

process (etat_courant)
begin -- process
start <= '0';
continue <= '0';
when S2=>
start <= '1';
continue <= '0';
when S3 | S4 =>
start <= '0';
continue <= '1';
when others => null;
end case;
end process;
end beh;
Solution
= ‘0’
e t_n
res
re
'
qu
’1
e
=
te
op
=
st
’1
'
stop=’1'
Dans le code VHDL suivant, indiquez les quatre erreurs détectées au moment de la compilation. Pour
chaque ligne comportant une erreur, donnez le code corrigé correspondant.
library ieee;
entity unitearithmetique is
generic (
W : positive := 8 -- largeur des opérandes
);
port(
A, B : in integer(W - 1 downto 0); -- les operandes de type signé
choix : in std_logic_vector(2 downto 0); -- le sélecteur d'opération
F : out std_logic_vector(W - 1 downto 0) -- le résultat
);
end unitearithmetique;
architecture arch of unitearithmetique is

begin
process(A, B, choix)
variable t : integer range 0 to 2**W-1;
begin
t <= to_integer(A * B);
case to_integer(unsigned(choix)) is
when 4 => F <= std_logic_vector(abs(A));
when 6 => F <= t;
end case;
end process;
end arch;
Solution
library ieee;
entity unitearithmetique is
generic (
W : positive := 8 -- largeur des opérandes
);
port(
A, B : in signed(W - 1 downto 0); -- les opérandes
choix : in std_logic_vector(2 downto 0); -- le sélecteur d'opération
F : out std_logic_vector(W - 1 downto 0) -- le résultat
);
end unitearithmetique;
architecture arch of unitearithmetique is
begin
process(A, B, choix)
variable t : integer range 0 to 2**W-1;
begin
t := to_integer(A * B);
case to_integer(unsigned(choix)) is
when 4 => F <= std_logic_vector(abs(A));
when 6 => F <=std_logic_vector(to_unsigned(t,W)) ;
when others => F <= (others => 'X');
end case;
end process;
end arch;
Examen final
Décembre 2010
Durée: 2h30.
Pondération: 40%.
Ordinateurs interdits.
Répondre dans le cahier fourni.
Ne pas remettre le questionnaire, sauf la dernière page qui doit être annotée et remise.
Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute sup-
INF3500 – examen final – automne 2010
Le réseau de Feistel est utilisé dans les algorithmes de chiffrement par bloc. Plusieurs algorithmes utili-
sent le réseau de Feistel, dont DES, Blowfish et RC5. Le diagramme suivant illustre un réseau de Feistel
simple à quatre étages. Les algorithmes cryptographiques basés sur un réseau de Feistel diffèrent princi-
palement dans le nombre d’étages et dans la nature de la fonction F.
K1 K2 K3 K4
A Y
F F F F
B oux oux oux oux Z
Le message à chiffrer est décomposé en un flux de nombres appliqués aux entrées A et B du réseau. Les
quatre clés secrètes K1, K2, K3 et K4 restent constantes pour le chiffrement du message. Les sorties Y et
Z sont un flux de nombres représentant le message chiffré.
On constate qu’à chaque étage le signal du haut est combiné à la clé par la fonction F. On effectue ensuite
un ou-exclusif bit à bit avec le signal du bas. À la fin de l’étage, les signaux du haut et du bas sont inter-
changés pour le prochain étage.
Ki
Supposez ici que tous fils du diagramme représentent un signal de
Fonction F
16 bits. Supposez que la fonction F consiste à appliquer une rota-
tion de l’entrée de 1 bit vers la droite puis à effectuer l’opération
Ror 1 oux
ou-exclusif bit à bit avec la clé Ki exprimée sur 16 bits.
a. (6 points) Considérez la déclaration d’entité suivante pour le diagramme du réseau de Feistel. Donnez
une architecture en VHDL synthétisable correspondant à cette entité et au diagramme.
library IEEE;
entity feistel4 is
generic (
W : positive := 16
);
port (
clk, reset : in std_logic;
A, B : in unsigned(W - 1 downto 0);
Y, Z : out unsigned(W - 1 downto 0)
);
end feistel4;
b. (4 points) Donnez le code VHDL pour un banc d’essai qui doit vérifier le fonctionnement de votre
architecture pour le réseau de Feistel.
Le banc d’essai doit générer des vecteurs de test aléatoire, calculer la réponse attendue et vérifier que les
valeurs des sorties sont conformes. Si un vecteur de test engendre une erreur à la sortie, le banc d’essai
doit s’arrêter et indiquer un message d’erreur à la console.
Solution
a.
architecture arch1 of feistel4 is
type unsigned2D is array(natural range <>) of unsigned(W - 1 downto 0);

constant K : unsigned2D(1 to 4) := (x"1234", x"5678", x"9ABC", x"DEF0");
signal A0, A1, A2, A3, A4, B0, B1, B2, B3, B4 : unsigned(W - 1 downto 0);
begin
-- registres à l'entrée pour A et B et à la sortie pour Y et Z

begin
if reset = '1' then
Y <= (others => '0');
Z <= (others => '0');
A0 <= (others => '0');
B0 <= (others => '0');
A0 <= A;
B0 <= B;
Y <= A4;
Z <= B4;
end if;
end process;
-- description du réseau comme tel

-- on pourrait aussi paramétrer A et B, puis utiliser une description
-- avec une boucle (dans un process) ou bien avec énoncé generate
B1 <= A0;
A1 <= (A0 ror 1) xor K(1) xor B0;
B2 <= A1;
A2 <= (A1 ror 1) xor K(2) xor B1;
B3 <= A2;
A3 <= (A2 ror 1) xor K(3) xor B2;
B4 <= A3;
A4 <= (A3 ror 1) xor K(4) xor B3;
end arch1;
b.
library IEEE;
entity feistel4_TB is
generic (W : positive := 16);
end feistel4_TB;
architecture arch1 of feistel4_TB is

constant K : unsigned2D(1 to 4) := (x"1234", x"5678", x"9ABC", x"DEF0");
signal clk, reset : std_logic := '0';
signal A, B, Y, Z : unsigned(W - 1 downto 0);

signal Y_att, Z_att : unsigned2D(0 to 2);
begin
clk <= not clk after 10 ns;

reset <= '1' after 0 ns, '0' after 22 ns;
UUT : entity feistel4(arch1) generic map(W)
port map (clk, reset, A, B, Y, Z);
process(clk, reset)
variable A_stim, B_stim : unsigned(W - 1 downto 0);
variable A_int, B_int : unsigned2D(1 to 5);
variable compteurReset : natural; -- début de la vérif. après reset
begin
if reset = '1' then

compteurReset := 0;
-- génération des stimuli

aleatoire := floor(aleatoire * real(2 ** W));
A_stim := to_unsigned(integer(aleatoire), W);

aleatoire := floor(aleatoire * real(2 ** W));
B_stim := to_unsigned(integer(aleatoire), W);
-- application des stimuli à l'entrée

A <= A_stim; B <= B_stim;
-- calcul des réponses attendues

A_int(1) := A_stim; B_int(1) := B_stim;
for q in 2 to 5 loop
A_int(q) := (A_int(q - 1) ror 1) xor K(q - 1) xor B_int(q - 1);
B_int(q) := A_int(q - 1);
end loop;
Y_att(0) <= A_int(5); Z_att(0) <= B_int(5);
-- retard des réponses attendues de 2 coups d'horloge dans le temps

-- voir le diagramme: 2 bascules de délai
Y_att(1) <= Y_att(0); Z_att(1) <= Z_att(0);
Y_att(2) <= Y_att(1); Z_att(2) <= Z_att(1);
-- vérification automatique des sorties

if (compteurReset >= 3) then
assert (Y = Y_att(2) and Z = Z_att(2))
report "erreur" severity error;
else
compteurReset := compteurReset + 1;
end if;
end if;
end process;
end arch1;
Considérez le diagramme du réseau de Feistel de la Question 1. Le réseau est implémenté sur un FPGA.
Après implémentation, on a caractérisé les différentes parties du réseau comme suit. Les bascules ont un
délai de 1 ns, un temps de préparation tsu de 0.25 ns, et un temps de maintien th de 0.1 ns. Les blocs de
fonction F ont un délai de 5 ns, et les ou-exclusif ont un délai de 3 ns. Les fils d’interconnexion ont des
délais de 0.1 ns chacun. Les blocs des clés n’ont pas de délais, ce sont des constantes.
a. (3 points) Identifiez le chemin critique du circuit et donnez la fréquence maximale d’opération.
b. (1 point) Donnez la latence du circuit en secondes et le débit du circuit en nombres de résultats par
seconde.
c. (2 points) On désire atteindre un débit minimal de 100 × 106 résultats par seconde. Indiquez comment
pipeliner le circuit pour atteindre ce niveau de performance. Annotez le diagramme de la dernière page du
questionnaire et remettez-le dans votre cahier d’examen.
d. (1 point) Expliquez comment le code VHDL décrivant le circuit doit être modifié pour inclure les regis-
tres de pipeline que vous avez identifiés à la partie c.. Ne donnez pas le code au complet. Donnez un seul
exemple pour un seul signal.
e. (3 points) Évaluez la latence du circuit pipeliné en secondes et le débit du circuit pipeliné en résultats
par seconde. Justifiez complètement votre réponse.
Solution
a. Le chemin critique va de la bascule pour le signal A à la bascule pour le signal Y, en passant par les
quatre boîtes ‘F’ et les quatre ou-exclusifs. Le délai total est donné par :
délai bascule + 4 × délai ‘F’ + 4 × délai ‘oux’ + 9 × délai fil + t su = 1 + 4 × 5 + 4 × 3 + 9 × 0.1 + 0.25 =
34.15 ns. La fréquence maximale est donc 29.3 MHz
b. La latence est de 34.15 ns. Le débit est de 29.3 × 106 résultats/seconde.
c. Une solution élégante consiste à ajouter un registre après chaque étage du réseau. Chaque étage a deux
entrées et deux sorties. On peut considérer les registres pour A et B comme les registres d’entrée du pre-
mier étage, et ajouter des registres aux deux entrées de chaque étage. Le nombre total de registres néces-
saires est donc de 6 (de 16 bits chacun).
d. Il faut placer les définitions des signaux d’entrée des étages à l’intérieur de la définition du processus, à
l’intérieur de la condition sur la transition sur le signal d’horloge. Par exemple,
B1 <= A0;
A1 <= (A0 ror 1) xor K(1) xor B0;
Pourraient être placés sous la ligne « elsif rising edge(clk) then »

e. Le chemin critique du circuit pipeliné devient
délai bascule + 1 × délai ‘F’ + 1 × délai ‘oux’ + 3 × délai fil + tsu = 1 + 5 + 3 + 3 × 0.1 + 0.25 = 9.55 ns.
La fréquence maximale est donc 104.7 MHz.
La latence du circuit devient 4 coups d’horloge, donc 38.2 ns (elle a augmenté).
Le débit du circuit devient 104.7 × 106 résultats/seconde (en régime permanent).
use IEEE.std_logic_1164.all; use IEEE.std_logic_1164.all;
entity module4 is entity module4TB is

port ( end module4TB;
A, B, C : in std_logic;
F, G : out std_logic architecture arch of module4TB is
);
end module4; signal A, B, C, F, G : std_logic;
architecture arch of module4 is begin
signal S1, S2: std_logic; UUT : entity module4(arch) port map

(A, B, C, F, G);
begin A <= '1' after 0 ns;
B <= '1' after 0 ns, '0' after 10 ns;
S1 <= A and B; C <= '0' after 0 ns;
S2 <= not(C or B);
end arch;
process(S1)
begin
F <= S1 or not(S2);
end process;
process(S2)
begin
G <= A xor B;
end process;
end arch;
a. (3 points) Donnez la liste des événements telle qu’elle pourrait être dressée par un simulateur qui exé-
cuterait le banc d’essai.
b. (3 points) En vous basant sur votre liste des événements, donnez la valeur de tous les ports et signaux
internes du module combinatoire en fonction du temps, en tenant compte des délais deltas.
Solution :
À t = 0 + 0 Δ, initialisation de la simulation (tout à ‘U’)
À t = 0 + 1 Δ, assignation de 110 à (A, B, C)
À t = 0 + 2 Δ, évaluation des signaux S1 et S2 (provoquées par les changements sur A, B, C)
À t = 0 + 3 Δ, évaluation de F et G (provoquées par les changements sur S1 et S2)
À t = 10 ns + 0 Δ, assignation de 0 à B
À t = 10 ns + 1 Δ, évaluation de S1 et S2 (provoquées par le changement sur B)
À t = 10 ns + 2 Δ, évaluation de F et G (provoquées par le changement sur S1 et S2)
b.
Faites la conception d’un processeur spécialisé pour calculer la moyenne arithmétique d’une plage de
cellules dans une mémoire RAM de 1024 cellules de 8 bits chacune. Les données en mémoire sont expri-
mées en complément à deux. La moyenne arithmétique est donnée par la somme des valeurs des cellules,
divisée par le nombre de cellules.
Avant d’effectuer le calcul, le processeur doit d’abord recevoir, sur deux ports distincts et simultanément,
l’adresse de la première cellule de la plage ainsi que le logarithme en base 2 du nombre de cellules entrant
dans le calcul de la moyenne. Le nombre de cellules est donc toujours une puissance positive de 2. Le
chargement est effectué quand un signal de contrôle spécial ‘go’ est activé, puis le processeur débute ses
opérations.
Le processeur doit effectuer le calcul, puis activer un signal spécial lorsque le résultat est appliqué à son
port de sortie. Il doit aussi activer un signal d’erreur spécial à la sortie si la cellule de départ et le nombre
de cellules spécifiés sont tels que la plage spécifiée dépasse la dernière cellule de la mémoire. La
moyenne doit être exprimée sur 8 bits.
a. (4 points) Donnez un diagramme montrant le chemin des données de ce processeur. Identifiez bien
chaque bloc et indiquez la largeur en bits de tous les ports et de tous les signaux.
b. (4 points) Spécifiez l’unité de contrôle de ce processeur par un diagramme d’états. Identifiez bien les
états et les conditions pour les transitions. Identifiez les signaux de contrôle appliqués au chemin des don-
nées.
Solution :
a.
La somme maximale est exprimée sur
18 bits en complément à deux: 1024 × somme
+127 ou 1024 × -128. /
18
addresseM adresse donnée / / D Q

8 18
(18 FF)
mémoire RAM reset

/ 18
1024 × 8 bits
initSomme
décaleur
nbits
à droite
/ résultat
8
b.
go = ‘1’ sinon
compteur > 0
init
adresseM <= addresseDepart;
départ nbits <= logNCellules; vérifier accumuler
compteur <= 2 ^ logNCellules terminé <= ‘0’
terminé <= ‘1’ erreurOut <= ‘0’ somme += M[adresseM]
somme <= 0 (initSomme <= ‘1’)
erreurOut <= ‘0’ compteur - -
terminé <= ‘0’
adresseM++
erreurOut <= ‘0’
terminé <= ‘0’
reset adresseM + compteur > 1023

go = ‘1’
sinon
erreur
terminé <= ‘1’
Réponses brèves.
a. (1 point) Énumérez quatre (4) éléments fondamentaux qu’on peut retrouver sur un FPGA présentement
en vente sur le marché.
a. Solution
Pour 0.25 point chacun: blocs de logique programmable (CLB), blocs d’entrées-sorties (IOB), réseau
d’interconnexions, circuits de routage rapide des retenues, blocs de mémoire intégrée, blocs de fonctions
arithmétiques avancées (multiplicateurs, multiplicateurs-accumulateurs), microprocesseurs fixes, circuits
de génération et de distribution d’horloge
Pour 0.125 point chacun : LUT, flip-flop, multiplexeur
b. (1 point) Lequel des énoncés suivants est vrai concernant des entités et architectures en VHDL?
i. un module peu avoir plusieurs déclarations d’entité mais une seule architecture;
ii. un module peut avoir seulement une déclaration d’entité mais plusieurs architectures;
iii. un module peut avoir seulement une déclaration d’entité et une seule architecture;
iv. un module peut avoir plusieurs déclarations d’entité et plusieurs architectures;
b. Solution : ii. Une entité, plusieurs architectures
c. (1 point) Considérez l’énoncé suivant : « Pour un circuit numérique implémenté sur FPGA, il n’y a pas
de désavantage à utiliser le principe du pipeline au maximum, parce que les bascules sont à toutes fins
pratiques gratuites. » Dites si vous êtes en accord ou en désaccord avec cet énoncé, et expliquez en quel-
ques lignes pourquoi.
c. Solution
Plutôt en accord. Une fois qu’on a choisi un FPGA en particulier, il n’y a pas de coût associé à
l’utilisation de chacune des ressources de la puce. Si le débit d’information doit être maximisé, alors le
fait de pipeliner autant que possible devrait être encouragé, en utilisant toutes les bascules disponibles.
Cependant, ajouter un grand nombre d’étages de pipeline augmente la latence du circuit, ce qui pourrait
aller à l’encontre des spécifications.
d. (1 point) Lequel/lesquels des énoncés suivants est/sont vrai(s) concernant VHDL?

i. Les processus d’une architecture s’exécutent de façon concurrente.
ii. À l’intérieur d’un processus, les assignations à des signaux sont faites de façon concurrente.
iii. À l’intérieur d’un processus, les assignations à des variables sont faites de façon séquentielle.
iv. Dans une boucle ne comportant pas d’énoncé wait, chaque itération prend effectivement un temps nul.
v. Dans une architecture, une assignation concurrente à un signal est une façon compacte d’écrire un pro-
cessus.
d. Solution : i, iii, iv, v.
e. (1 point) Énoncez deux types d’avertissements qu’un analyseur statique de code VHDL pourrait don-
ner.
e. Solutions possibles : Opérandes de largeurs différentes dans une expression; Énoncés conditionnels
dont tous les cas ne sont pas couverts et qui créent des états implicites; Énoncés conditionnels qui se re-
coupent; Nom d’entité différent du nom du fichier; Insertion de signaux de contrôle dans le chemin d’une
horloge; Signaux ou variables qui ne sont pas initialisés avant d’être utilisés; Signaux ou variables aux-
quels on n’assigne jamais de valeur ou qui ne sont jamais utilisés; Expression constante dans une structu-
re de condition, etc.
f. (1 point) Expliquez deux problèmes qui peuvent survenir si on utilise un commutateur d’une planchette
d’expansion (contrôlé par un humain) comme entrée directe pour une machine à états implémentée dans
un FPGA sur une carte de développement.
f. Solutions possibles: 1. Le commutateur rebondit, ce qui crée plusieurs entrées de suite qui changent de
valeur. 2. Le commutateur peut être activé pendant une période interdite d’une bascule, la plaçant dans un
état métastable. 3. Si plusieurs bascules dépendent de la valeur du commutateur, il est possible que certai-
nes d’entre elles voient une valeur différente des autres si le commutateur est activé juste au mauvais
moment, plaçant la machine à états dans un état interdit.
Nom : ______________________________________ Matricule : _______________________________
Question 2
Détacher cette page, annotez-la et remettez-la avec votre cahier d’examen.
K1 K2 K3 K4
A Y
F F F F
B oux oux oux oux Z
Examen intra
Lundi 25 octobre 2010
Durée: 2h.
Pondération: 20%.
Ordinateurs interdits.
Répondre dans le cahier fourni et soumettre les pages du questionnaire indiquées.
Ne pas remettre le questionnaire.
Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute
a. (2 points)
library ieee;
-- Cette bascule JK a le comportement suivant.

-- Les valeurs des signaux de contrôle J et K déterminent l'état de la bascule
-- lors d'une transition positive du signal d'horloge:
-- si JK == 00, pas de changement
-- si JK == 01, Q passe à 0
-- si JK == 10, Q passe à 1
-- si JK == 11, Q est inversé
entity basculeJK is
port (
clk, J, K : in std_logic;
Q : out std_logic
);
end basculeJK;
Solution
architecture arch of basculeJK is
begin
process(CLK, reset)
variable JK : std_logic_vector(1 downto 0);
variable Qint : std_logic := 'X';
begin
JK := (J, K);
case JK is
when "01" => Qint := '0';
when "10" => Qint := '1';
when "11" => Qint := not(Qint);
when others => Qint := Qint;
end case;
end if;
Q <= Qint;
end process;
end arch;
b. (2 points)
library ieee;
-- Ce compteur a le comportement suivant.

-- Le compte s'effectue sur une transition négative du signal d'horloge.
-- Le compte est activé quand go == '1'.
-- Le signal UD détermine si le compte est vers le haut ('1') ou vers le bas ('0').
-- Le compte est remis à zéro de façon asynchrone quand reset = '1';
entity compteurUD is
generic (W : integer := 8);
port (
clk, reset, go, UD : in std_logic;
compte : out signed(W - 1 downto 0)
);
end compteurUD;
Solution
architecture arch of compteurUD is
begin
process(CLK)
variable compte_int : signed(W - 1 downto 0);
begin
if reset = '1' then
compte_int := (others => '0');
else
if falling_edge(CLK) then
if go = '1' then
if UD = '1' then
compte_int := compte_int + 1;
else
compte_int := compte_int - 1;
end if;
end if;
end if;
end if;
compte <= compte_int;
end process;
end arch;
Considérez le problème de la conception d’un multiplicateur complexe devant être implémenté sur FPGA.
Les entrées du circuit sont A, B, C, D, représentant les nombres Z1 = A + jB et Z2 = C + jD. Les sorties
du circuit sont E et F représentant Z3 = E + jF, avec Z3 = Z1 × Z2.
Le diagramme suivant décrit un multiplicateur complexe. Les entrées sont des valeurs entières signées
exprimées avec 16 bits. Les sorties des multiplicateurs sont signées et exprimées sur 32 bits, et les sorties
des additionneurs sont signées et exprimées sur 33 bits. Tous les registres partagent une même horloge
CLK et un signal de réinitialisation synchrone reset.
Donnez le code VHDL synthétisable correspondant à ce diagramme.
A
AC
E
C AD
BC
F
B
BD
Solution
library IEEE;
entity multiplicateurcomplexe is
generic (
W : positive := 16 -- nombre de bits des opérandes d'entrée
);
port (
A, B, C, D : in signed(W - 1 downto 0);
E, F : out signed(2 * W downto 0)
);
end multiplicateurcomplexe;
architecture arch of multiplicateurcomplexe is

signal At, Bt, Ct, Dt : signed(W - 1 downto 0);
signal AC, AD, BC, BD : signed(2 * W - 1 downto 0);
begin
process(clk, reset)
begin
if rising_edge(clk) then
if reset = '1' then
At <= (others => '0'); Bt <= (others => '0');
Ct <= (others => '0'); Dt <= (others => '0');
AC <= (others => '0'); BC <= (others => '0');
AD <= (others => '0'); BD <= (others => '0');
E <= (others => '0'); F <= (others => '0');
else
At <= A; Bt <= B; Ct <= C; Dt <= D;
AC <= At * Ct; AD <= At * Dt;
BC <= Bt * Ct; BD <= Bt * Dt;
E <= resize(AC, E'length) - resize(BD, E'length);
F <= resize(AD, F'length) + resize(BC, F'length);
end if;
end if;
end process;
end arch;
Considérez le code VHDL suivant pour un arbitre de bus rudimentaire.

Donnez un schéma du circuit correspondant à ce code.
library ieee;
entity arbitreBus is
generic (n : positive := 2);
port(
requetes : in std_logic_vector(2 ** n - 1 downto 0);
donneesIn : in std_logic_vector(2 ** n - 1 downto 0);
donneeOut, donneeValide : out std_logic
);
end arbitreBus;
architecture arch of arbitreBus is

signal choix : unsigned(n - 1 downto 0);
begin
process(requetes, donneesIn)
begin
donneeValide <= '0';
for k in 2 ** n - 1 downto 0 loop
if requetes(k) = '1' then
choix <= to_unsigned(k, n);
exit;
end if;
end loop;
end process;
process(choix, donneesIn)
begin
donneeOut <= donneesIn(to_integer(choix));
end process;
end arch;
Solution
DonneesIn(3)
DonneesIn(3)
DonneesIn(3) donneeOut
DonneesIn(3)
Requetes(3) 3
A1
Requetes(2) 2
A0
Requetes(1) 1
Encodeur à priorité
Requetes(0) 0 V donneeValide
Considérez le code VHDL suivant. Donnez un diagramme d’états correspondant.

library IEEE; Solution
entity machineetats is
port (
);
end machineetats;
architecture arch of machineetats is

type type_etat is (S1, S2, S3);
begin
begin
etat <= S1;
case etat is
when S1 =>
if x = "00" then
etat <= S3;
elsif x = "01" then
etat <= S2;
end if;
when S2 =>
if x = "10" then
etat <= S3;
elsif x = "11" then
etat <= S1;
end if;
when S3 =>
etat <= S1;
end case;
end if;
end process;
process(x, etat)
begin
case etat is
when S1 | S3 =>
sortie <= '1';
when S2 =>
sortie <= '0';
end case;
end process;
end arch;
Réponses brèves.
a. (0.5 point) Placez les technologies de logique programmable suivantes en ordre chronologique crois-
sant d’apparition sur le marché : CPLD, EPROM, FPGA, GAL, LSI, MSI, PLA/PAL, SSI
b. (0.5 point) Donnez une différence architecturale importante entre un CPLD et un GAL.
c. (0.5 point) Donnez une différence architecturale importante entre un CPLD et un FPGA.
d. (0.5 point) Nommez deux technologies de programmation utilisées dans des FPGAs présentement sur
le marché.
e. (1 point) Énumérez quatre considérations d’implémentation qui devraient être prises en compte lors de
la conception d’un système numérique.
f. (1 point) Donnez un diagramme simplifié du flot de conception que vous avez suivi dans les laboratoi-
res du cours à ce jour.
Solution
a. SSI, MSI, LSI, EPROM, PLA/PAL, GAL, CPLD, FPGA
b. un CPLD incorpore effectivement plusieurs PAL/PLA ou GALs sur une seule puce; ajout d’un réseau
d’interconnections dans un CPLD
c. blocs fonctionnels de grande taille vs CLBs réalisant des fonctions simples; un réseau
d’interconnexions central vs connexions distribuées
d. SRAM, anti-fusibles, mémoire Flash
e. puissance consommée, précision des calculs, taille du circuit, taux de traitement
f. fig. 4.1 des notes de cours simplifiée : code VHDL et schémas -> vérification par simulation -> synthè-
se -> implémentation -> génération de fichier de configuration et programmation du FPGA
Considérez le code VHDL suivant. Montrez, sur le diagramme fourni, un résultat possible de la synthèse
et de l’implémentation de ce code sur un FPGA Virtex II Pro. Indiquez directement sur le dessin où cha-
que signal se situe ainsi que les interconnections entre les blocs. Indiquez dans les tables de vérité four-
nies le contenu de chacune des tables de conversion que vous utilisez.
Écrivez votre nom et matricule et remettez les deux feuilles dans votre cahier d’examen.
library IEEE;
entity compteurJohnson is
generic (
W : positive := 3
);
port (
compte : out std_logic_vector(W - 1 downto 0);
alerte : out std_logic
);
end compteurJohnson;
architecture arch1 of compteurJohnson is

begin
process(clk, reset)
variable c : std_logic_vector(W - 1 downto 0);
begin
if reset = '1' then
c := (others => '0');
else
c := c(W - 2 downto 0) & not(c(W - 1));
end if;
end if;
if c = "111" then
alerte <= '1';
else
alerte <= '0';
end if;
compte <= c;
end process;
end arch1;
Question 6 - Annotez cette page et remettez-la avec votre cahier d’examen
Nom : ____________________________ Matricule : __________________________
G4
YQ
G3 D Q
Table de
conversion
G2 G CLK
16 X 1 S0
G1
H1 S1
F4
XQ
F3 D Q
Table de
conversion
F2 F CLK
16 X 1 S2
F1
S3
CLK
G4
YQ
G3 D Q
Table de
conversion
G2 G CLK
16 X 1 S0
G1
H1 S1
F4
XQ
F3 D Q
Table de
conversion
F2 F CLK
16 X 1 S2
F1
S3
CLK
Question 6 - Annotez cette page et remettez-la avec votre cahier d’examen
Nom : ____________________________ Matricule : __________________________
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
Solution
G4
compte(1) YQ compte(2)
G3 D Q
Table de
conversion
G2 G CLK
16 X 1 S0
G1
H1 S1
F4
compte(0) XQ compte(1)
F3 D Q
Table de
conversion
F2 F CLK
16 X 1 S2
F1
S3
CLK
G4
compte(2) YQ compte(0)
G3 D Q
Table de
conversion
G2 G CLK
16 X 1 S0
G1
H1 S1
F4
compte(2) XQ
F3 D Q
compte(1) Table de
conversion
F2 F CLK
compte(0) 16 X 1 S2
F1
X alerte
S3
CLK
Solution
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 1 0
0 0 1 0 0 0 0 1 0 0
0 0 1 1 0 0 0 1 1 0
0 1 0 0 0 0 1 0 0 0
0 1 0 1 0 0 1 0 1 0
0 1 1 0 0 0 1 1 0 0
0 1 1 1 0 0 1 1 1 0
1 0 0 0 1 1 0 0 0 1
1 0 0 1 1 1 0 0 1 1
1 0 1 0 1 1 0 1 0 1
1 0 1 1 1 1 0 1 1 1
1 1 0 0 1 1 1 0 0 1
1 1 0 1 1 1 1 0 1 1
1 1 1 0 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 1 0 0 0 0 0
0 0 0 1 1 0 0 0 1 0
0 0 1 0 1 0 0 1 0 0
0 0 1 1 1 0 0 1 1 0
0 1 0 0 1 0 1 0 0 0
0 1 0 1 1 0 1 0 1 0
0 1 1 0 1 0 1 1 0 0
0 1 1 1 1 0 1 1 1 0
1 0 0 0 0 1 0 0 0 0
1 0 0 1 0 1 0 0 1 0
1 0 1 0 0 1 0 1 0 0
1 0 1 1 0 1 0 1 1 0
1 1 0 0 0 1 1 0 0 0
1 1 0 1 0 1 1 0 1 0
1 1 1 0 0 1 1 1 0 1
1 1 1 1 0 1 1 1 1 1
Examen final
Mercredi 18 août 2010
Durée: 2h30.
Pondération: 40%.
 Ordinateurs interdits.
 Un dictionnaire autorisé.
 Répondre à toutes les questions, la valeur de chaque question est indiquée.
 Répondre en français ou en anglais.
 Répondre dans le cahier fourni et soumettre la page du questionnaire indiquée.
 Ne pas remettre le questionnaire.
 Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute
L’algorithme de Box-Muller permet de générer des variables aléatoires suivant la distribution normale.
Pour ce faire, il se fonde sur le principe suivant : soient u0 et u1 deux variables indépendantes suivant une
distribution uniforme sur l’intervalle (0,1), alors sin log et cos log
sont deux variables indépendantes suivant la distribution normale.
Dans un article datant de 20061, Lee et al. proposent le circuit de la Figure 1 pour implémenter
l’algorithme de Box-Muller sur FPGA. Les lignes horizontales représentent des niveaux de registres.
a) (3 pts) En supposant que le circuit fonctionne à une fréquence de 100 MHz, évaluez les métriques
suivantes en justifiant clairement vos réponses :
 La latence du circuit en cycles d’horloge.
 La latence du circuit en secondes.
 Le débit en nombre de résultats par cycle d’horloge.
 Le débit en nombre de résultats par seconde.
On vous demande d’évaluer l’opportunité de remplacer la boîte SIN/COS (et les niveaux de registres qui
lui sont associés) par un processeur CORDIC produisant simultanément les deux sorties sinus et cosinus
demandées.
b) (3 pts) Sachant que le processeur CORDIC a une latence (en cycles d’horloge) égale à la largeur
en bits de l’entrée, et en supposant que la fréquence du circuit passe de 100 MHz à 250 MHz grâce à
cette solution, évaluez les métriques suivantes en justifiant clairement vos réponses :
c) (2 pts) À la lumière de ces résultats, discutez l’intérêt de cette nouvelle solution.
1
Lee, D.-U et al. A Hardware Gaussian Noise Generator Using the Box-Muller Method and Its Error Analysis.
IEEE Transactions on Computers, 55(6), June 2006.
Figure 1 Générateur de variables normales de Lee et al.
Un collègue vous suggère d’utiliser le code suivant pour réaliser un circuit effectuant un tri sur quatre
nombres en entrées : a, b, c et d. Ainsi, si (a, b, c, d) = (6, 4, 2, 8), les sorties devraient être af-
fectées après 5 cycles d’horloge, de sorte que (x, y, z, w) = (2, 4, 6, 8).
library ieee;
entity trieuse is
generic(
width : positive := 18
);
port(
clk : in std_logic;
a, b, c, d : in unsigned(width-1 downto 0);
x, y, z, w : out unsigned(width-1 downto 0)
);
end trieuse;
architecture arch of trieuse is
type aunsigned is array (0 to 3) of unsigned(width-1 downto 0);

type a_aunsigned is array(0 to 4) of aunsigned;
signal aus : a_aunsigned;
begin
process( clk ) is
begin
if ( rising_edge( clk ) ) then
for j in 0 to 1 loop
if( aus( 2*i )( 2*j ) > aus( 2*i )( 2*j+1 ) ) then
aus( 2*i+1 )( 2*j ) <= aus( 2*i )( 2*j+1 );
aus( 2*i+1 )( 2*j+1 ) <= aus( 2*i )( 2*j );
else
aus( 2*i+1 )( 2*j ) <= aus( 2*i )( 2*j );
aus( 2*i+1 )( 2*j+1 ) <= aus( 2*i )( 2*j+1 );
end if;
end loop;
aus( 2*i+2 )( 0 ) <= aus( 2*i+1 )( 0 );

aus( 2*i+2 )( 3 ) <= aus( 2*i+1 )( 3 );
if( aus( 2*i+1 )( 1 ) > aus( 2*i+1 )( 2 ) ) then

aus( 2*i+2 )( 1 ) <= aus( 2*i+1 )( 2 );
aus( 2*i+2 )( 2 ) <= aus( 2*i+1 )( 1 );
else
aus( 2*i+2 )( 1 ) <= aus( 2*i+1 )( 1 );
aus( 2*i+2 )( 2 ) <= aus( 2*i+1 )( 2 );
end if;
end loop;
aus( 0 ) <= (a, b, c, d);

end if;
end process;
(x, y, z, w) <= aus( 4 );
end arch;
Vous n’êtes pas certain du bon fonctionnement du circuit trieuse qui vous a été fourni et vous désirez
élaborer une stratégie de test.
a) (1 pt) Quelle est le nombre de vecteurs de test nécessaires pour effectuer un test exhaustif de l’entité
trieuse ? Justifiez votre réponse par un calcul.
b) (1 pt) Quel est le nombre total de combinaisons de choix de branchements qu’il faut considérer pour
vérifier entièrement la couverture de branchements de l’entité trieuse ? Justifiez votre réponse par
un calcul.
c) (1 pt) Proposez un partitionnement en classes des entrées du circuit trieuse permettant de minimi-
ser la taille des vecteurs de tests.
d) (1 pt) Pour chacune des classes identifiées, proposez un exemplaire de donnée pouvant représenter
adéquatement les autres membres de la classe.
e) (1 pt) Donnez le nombre minimal de vecteurs de test nécessaires pour effectuer un test faible sur
l’entité trieuse, et ce en recourant aux classes que vous avez identifiées. Justifiez votre réponse.
f) (1 pt) Donnez le nombre minimal de vecteurs de test nécessaires pour effectuer un test fort sur l’entité
trieuse, et ce en recourant aux classes que vous avez identifiées. Justifiez votre réponse.
g) (2 pts) Quelle est en pourcentage la couverture de branchements obtenue en appliquant un test fort ?
Justifiez votre réponse.
Votre collègue vous fournit le banc d’essai suivant qu’il affirme avoir utilisé pour s’assurer du bon fonc-
tionnement de son circuit trieuse.
library ieee;
entity trieuse_tb is
generic(width : positive := 4);
end trieuse_tb;
architecture tb of trieuse_tb is
component trieuse is
generic(
);
port(
clk : in std_logic;
);
end component;
signal clk : std_logic := '1';

signal rst : std_logic := '1';
type tb_a_aunsigned is array(0 to 7) of aunsigned;

constant aus : tb_a_aunsigned :=
((x"2", x"4", x"6", x"8"), (x"2", x"4", x"8", x"6"), (x"2", x"6", x"4", x"8"),
(x"2", x"6", x"8", x"4"), (x"2", x"8", x"4", x"6"), (x"2", x"8", x"6", x"4"),
(x"4", x"2", x"6", x"8"), (x"4", x"2", x"8", x"6"));
signal entrees, sorties : aunsigned;

signal a, b, c, d, x, y, z, w : unsigned(width-1 downto 0);
begin
dut : trieuse generic map(width) port map(clk, a, b, c, d, x, y, z, w);
rst <= '1' after 0 ns, '0' after 15 ns;

clk <= not( clk ) after 5 ns;
(a, b, c, d) <= entrees;

sorties <= (x, y, z, w);
process( clk ) is
variable i : integer := 0;
begin
if( rst = '1' ) then
entrees <= (x"0", x"0", x"0", x"0");
i := 0;
elsif( falling_edge( clk ) ) then
if ( i >= 5 ) then
assert ( sorties = (x"2", x"4", x"6", x"8") )
report "Erreur sur les entrees" severity error;
end if;
if ( i < 8 ) then
entrees <= aus( i );
i := i + 1;
elsif( i = 13 ) then
report "Fin de simulation simulation" severity failure;
else
i := i + 1;
end if;
end if;
end process;
end tb;
h) (1 pt) Ce banc d’essai vous assure-t-il hors de tout doute du bon fonctionnement du circuit ? Justifiez
clairement votre réponse.
i) (2 pts) Donnez en pourcentage la couverture de branchements obtenue en appliquant ce banc d’essai.

Justifiez votre réponse par un calcul.
Le circuit suivant permet d’additionner 4 entiers X, Y, Z et W en parallèle. Le résultat apparaît sur le bus S.
Les entiers X, Y, Z, W et S sont exprimés avec n bits. On a donc X=(xn-1, xn-2,…,x1, x0),
Y=(yn-1, yn-2,…, y1, y0), et de façon similaire pour Z, W et S. Le circuit itératif est composé de n modules
identiques connectés en cascade comme montré à la Figure 2.
Figure 2 Additionneur itératif à 4 entrées.
Les équations logiques associées à la cellule i du circuit itératif sont données par :
si = xi  yi  zi  wi  cin0i
ti = xiyi  xizi  xiwi  xicin0i  yizi  yiwi  yicin0i  ziwi  zicin0i  wicin0i
cout0i = ti  cin1i
cout1i = xiyiziwi  xiyizicin0i  xiyiwicin0i  xiziwicin0i  yiziwicin0i  ticin1i
On vous demande de compléter le code VHDL donné plus loin pour implémenter un additionneur séquen-
tiel série à n bits utilisant le module itératif et en vous basant sur le chemin de données suivant :
Figure 3 Chemin de données pour un additionneur sériel
library ieee;
entity serial_adder is
generic(data_width : integer := 8); -- largeur des données
port(
clk : in std_logic; -- signal d'horloge
rst : in std_logic; -- signal de réinitialisation asynchrone
go : in std_logic; -- signal de début de traitement
Xi, Yi, Zi, Wi : in std_logic; -- bits des nombres sériels à additionner
valid : out std_logic; -- '1' lorsque la sortie S est valide
S : out std_logic -- résultat sériel de l'addition
);
end serial_adder;
architecture arch of serial_adder is
component cell_i is port(

xi, yi, zi, wi, cin0i, cin1i : in std_logic;
si, cout0i, cout1i : out std_logic
); end component;
signal si cin0i, cin1i : std_logic;

signal cout0i, cout1i : std_logic;
-- a) Déclaration de vos signaux
begin
u_iter : cell_i port map(Xi, Yi, Zi, Wi, cin0i, cin1i, si, cout0i, cout1i);
-- b) Votre implémentation
end arch;
On considère un circuit qui réalise le contrôle d’une porte dont l’ouverture est commandée par un code
d’accès. Le code d’accès est saisi au moyen d’un clavier numérique, tel qu’illustré à la Figure 4.
Figure 4 Système d'ouverture de porte
Au départ, la porte est fermée. Pour l’ouvrir, l’usager doit entrer le symbole ‘*’, taper les quatre chiffres
de son code et terminer la saisie de son code par le symbole ‘’. Si le code est valide, le circuit maintient
une tension sur le signal ouverture qui force l’ouverture de la porte. Le circuit est réinitialisé lorsque la
porte est refermée, ce qui déclenche une impulsion sur le signal asynchrone rst.
a) (4 pts) Donnez un diagramme d’états pour le circuit séquentiel implémentant une machine à états
commandant cette porte.
b) (4 pts) Donnez en VHDL une description possible d’un circuit séquentiel implémentant la ma-
chine à états décrite par votre diagramme d’états. L’entête du code VHDL que vous devez fournir
suit :
package symboles is
type symbole is ('#', '*', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9');
type code is array(0 to 3) of symbole;
end symboles;
library ieee;
use work.symboles.all;
entity ouverture_porte is
generic(
mon_code : code := ('1','8', '6','4')
);
port(
entree : in symbole; -- signal de début de traitement
ouverture : out std_logic -- signal ouvrant la porte
);
end ouverture_porte ;
architecture arch of ouverture_porte is
Questions brèves.
a) (1 pt) Donnez quatre fréquences d’horloge qu’il est possible de générer exactement à partir d’une hor-
loge de référence de 100 MHZ, telles que :
 la première soit entre 10 kHz et 500 kHz ;

 la seconde entre 500 kHz et 1 MHz ;
 la troisième entre 1 MH et 10 MHz et
 la quatrième entre 10 MHz et 100 MHz.
b) (1 pt) Considérez le processeur à usage spécifique et le processeur à usage général et donnez un avan-
tage et un inconvénient à chacune de ces options pour implémenter un algorithme de tri sur FPGA. Vous
pouvez utiliser l’exemple de la question 2 comme référence.
c) (0.75 pt) Donnez quatre étapes importantes dans le flot de conception d’un circuit numérique sur
FPGA.
d) (0.75 pt) Discutez l’option d’utiliser un test pseudo-aléatoire pour tester une machine à états où le vec-
teur de test aléatoire alimente l’entrée du circuit séquentiel.
e) (0.75 pt) Donnez un exemple d’application où la latence initial d’une architecture à pipeline n’a aucun
impact sur la performance du système.
f) (0.75 pt) Donnez un exemple d’application où la latence initial d’une architecture à pipeline a un im-
pact critique sur la performance du système.
Examen final
Mercredi 18 août 2010
Durée: 2h30.
Pondération: 40%.
L’algorithme de Box-Muller permet de générer des variables aléatoires suivant la distribution normale.
Pour ce faire, il se fonde sur le principe suivant : soient u0 et u1 deux variables indépendantes suivant une
distribution uniforme sur l’intervalle (0,1), alors sin log et cos log
sont deux variables indépendantes suivant la distribution normale.
Dans un article datant de 20061, Lee et al. proposent le circuit de la Figure 1 pour implémenter
l’algorithme de Box-Muller sur FPGA. Les lignes horizontales représentent des niveaux de registres.
a) (3 pts) En supposant que le circuit fonctionne à une fréquence de 100 MHz, évaluez les métriques
suivantes en justifiant clairement vos réponses :
La latence du circuit est donnée par le nombre de niveaux de registres sur le chemin de données. Soit
1+4+2+1 = 1+6+1 = 8 cycles d’horloge, soit 8·10 ns = 80 ns pour une horloge de 100 MHz.
Comme le circuit possède deux sorties et que le circuit est une architecture à pipeline, il produit deux
résultats par cycle d’horloge, soit 2·100·106=200 millions de résultats par seconde.
On vous demande d’évaluer l’opportunité de remplacer la boîte SIN/COS (et les niveaux de registres qui
lui sont associés) par un processeur CORDIC produisant simultanément les deux sorties sinus et cosinus
demandées.
b) (3 pts) Sachant que le processeur CORDIC a une latence (en cycles d’horloge) égale à la largeur
en bits de l’entrée, et en supposant que la fréquence du circuit passe de 100 MHz à 250 MHz grâce à
cette solution, évaluez les métriques suivantes en justifiant clairement vos réponses :
La latence du circuit est donnée 1 + 16 + 1 = 18 cycles d’horloge, l’équivalent de 18·4 ns = 72 ns pour
une horloge de 250 MHz.
Comme le circuit possède deux sorties mais que le circuit possède un composant itératif, il produit deux
résultats tous les 16 cycles d’horloge, soit 1/8 résultat par cycle d’horloge, 1/8·250·106=31.25 millions de
résultats par seconde.
c) (2 pts) À la lumière de ces résultats, discutez l’intérêt de cette nouvelle solution.
Le gain en fréquence obtenu au moyen du CORDIC ne compense pas pour la perte subie sur le débit, de
sorte que cette solution n’est pas opportune.
1
Lee, D.-U et al. A Hardware Gaussian Noise Generator Using the Box-Muller Method and Its Error Analysis.
IEEE Transactions on Computers, 55(6), June 2006.
Figure 1 Générateur de variables normales de Lee et al.
Un collègue vous suggère d’utiliser le code suivant pour réaliser un circuit effectuant un tri sur quatre
nombres en entrées : a, b, c et d. Ainsi, si (a, b, c, d) = (6, 4, 2, 8), les sorties devraient être af-
fectées après 5 cycles d’horloge, de sorte que (x, y, z, w) = (2, 4, 6, 8).
library ieee;
entity trieuse is
generic(
);
port(
clk : in std_logic;
);
end trieuse;
architecture arch of trieuse is

type a_aunsigned is array(0 to 4) of aunsigned;
signal aus : a_aunsigned;
begin
process( clk ) is
begin
for j in 0 to 1 loop
if( aus( 2*i )( 2*j ) > aus( 2*i )( 2*j+1 ) ) then
aus( 2*i+1 )( 2*j ) <= aus( 2*i )( 2*j+1 );
aus( 2*i+1 )( 2*j+1 ) <= aus( 2*i )( 2*j );
else
aus( 2*i+1 )( 2*j ) <= aus( 2*i )( 2*j );
aus( 2*i+1 )( 2*j+1 ) <= aus( 2*i )( 2*j+1 );
end if;
end loop;
aus( 2*i+2 )( 0 ) <= aus( 2*i+1 )( 0 );

aus( 2*i+2 )( 3 ) <= aus( 2*i+1 )( 3 );
if( aus( 2*i+1 )( 1 ) > aus( 2*i+1 )( 2 ) ) then

aus( 2*i+2 )( 1 ) <= aus( 2*i+1 )( 2 );
aus( 2*i+2 )( 2 ) <= aus( 2*i+1 )( 1 );
else
aus( 2*i+2 )( 1 ) <= aus( 2*i+1 )( 1 );
aus( 2*i+2 )( 2 ) <= aus( 2*i+1 )( 2 );
end if;
end loop;
aus( 0 ) <= (a, b, c, d);

end if;
end process;
(x, y, z, w) <= aus( 4 );
end arch;
Vous n’êtes pas certain du bon fonctionnement du circuit trieuse qui vous a été fourni et vous désirez
élaborer une stratégie de test.
a) (1 pt) Quelle est le nombre de vecteurs de test nécessaires pour effectuer un test exhaustif de l’entité
trieuse ? Justifiez votre réponse par un calcul.
Comme il y a 4 entrées et que chaque entrée possède width bits, il faudrait donc 24width vecteurs de test
pour effectuer un test exhaustif. Dans le cas où width = 18, cela revient à 272 vecteurs de test.
b) (1 pt) Quel est le nombre total de combinaisons de choix de branchements qu’il faut considérer pour
vérifier entièrement la couverture de branchements de l’entité trieuse ? Justifiez votre réponse par
un calcul.
Il y a au total 6 branchements à 2 choix, soit un total de 26=64 combinaisons de choix de branchement.
c) (1 pt) Proposez un partitionnement en classes des entrées du circuit trieuse permettant de minimi-
ser la taille des vecteurs de tests.
Comme nous avons quatre entrées, on peut imaginer quatre classes ordonnées (identiques) pour chaque
entrée: 1) les valeurs les plus petites ; 2) juste un peu plus grandes ; 3) encore plus grandes ; 4) les plus
grandes. Pour width = 4, on pourrait imaginer classe_i-1 = {0, 1, 2, 3}, classe_i-2 = {4, 5, 6, 7},
classe_i-3 = {8, 9, 10, 11}, classe_i-4 = {12, 13, 14, 15}.
d) (1 pt) Pour chacune des classes identifiées, proposez un exemplaire de donnée pouvant représenter
adéquatement les autres membres de la classe.
classe_i-1 ≡ 2 ; classe_i-2 ≡ 4 ; classe_i-3 ≡ 9 ; classe_i-4 ≡ 15.
e) (1 pt) Donnez le nombre minimal de vecteurs de test nécessaires pour effectuer un test faible sur
l’entité trieuse, et ce en recourant aux classes que vous avez identifiées. Justifiez votre réponse.
Un test faible pour être réalisé avec quatre vecteurs de test. Le premier comporte uniquement des entrées
de la classe_i-1, le seconde de la classe_i-2, et ainsi de suite.
f) (1 pt) Donnez le nombre minimal de vecteurs de test nécessaires pour effectuer un test fort sur l’entité
trieuse, et ce en recourant aux classes que vous avez identifiées. Justifiez votre réponse.
Pour effectuer un test fort, il faut considérer toutes les combinaisons de classe, soit 44 = 256 vecteurs
g) (2 pts) Quelle est en pourcentage la couverture de branchements obtenue en appliquant un test fort ?
Justifiez votre réponse.
Un test fort aura une couverture de 100% car toutes les combinaisons de branchement sont couvertes.
Votre collègue vous fournit le banc d’essai suivant qu’il affirme avoir utilisé pour s’assurer du bon fonc-
tionnement de son circuit trieuse.
library ieee;
entity trieuse_tb is
generic(width : positive := 4);
end trieuse_tb;
architecture tb of trieuse_tb is
component trieuse is
generic(
);
port(
clk : in std_logic;
);
end component;
signal clk : std_logic := '1';

signal rst : std_logic := '1';

type tb_a_aunsigned is array(0 to 7) of aunsigned;
constant aus : tb_a_aunsigned :=
((x"2", x"4", x"6", x"8"), (x"2", x"4", x"8", x"6"), (x"2", x"6", x"4", x"8"),
(x"2", x"6", x"8", x"4"), (x"2", x"8", x"4", x"6"), (x"2", x"8", x"6", x"4"),
(x"4", x"2", x"6", x"8"), (x"4", x"2", x"8", x"6"));
signal entrees, sorties : aunsigned;

signal a, b, c, d, x, y, z, w : unsigned(width-1 downto 0);
begin
dut : trieuse generic map(width) port map(clk, a, b, c, d, x, y, z, w);
rst <= '1' after 0 ns, '0' after 15 ns;

clk <= not( clk ) after 5 ns;
(a, b, c, d) <= entrees;

sorties <= (x, y, z, w);
process( clk ) is
variable i : integer := 0;
begin
entrees <= (x"0", x"0", x"0", x"0");
i := 0;
elsif( falling_edge( clk ) ) then
if ( i >= 5 ) then
assert ( sorties = (x"2", x"4", x"6", x"8") )
report "Erreur sur les entrees" severity error;
end if;
if ( i < 8 ) then
entrees <= aus( i );
i := i + 1;
elsif( i = 13 ) then
report "Fin de simulation simulation" severity failure;
else
i := i + 1;
end if;
end if;
end process;
end tb;
h) (1 pt) Ce banc d’essai vous assure-t-il hors de tout doute du bon fonctionnement du circuit ? Justifiez
clairement votre réponse.
Non, car même si l’on admet que classe_i-1 ≡ 2 ; classe_i-2 ≡ 4 ; classe_i-3 ≡ 6 ; classe_i-4 ≡ 8, ceci n’est
même pas un test faible.
i) (2 pts) Donnez en pourcentage la couverture de branchements obtenue en appliquant ce banc d’essai.

Justifiez votre réponse par un calcul.
Nous avons un total de 8 cas de branchements sur un total de 64, soit une couverture de 12.5 %.
Le circuit suivant permet d’additionner 4 entiers X, Y, Z et W en parallèle. Le résultat apparaît sur le bus S.
Les entiers X, Y, Z, W et S sont exprimés avec n bits. On a donc X=(xn-1, xn-2,…,x1, x0),
Y=(yn-1, yn-2,…, y1, y0), et de façon similaire pour Z, W et S. Le circuit itératif est composé de n modules
identiques connectés en cascade comme montré à la Figure 2.
Figure 2 Additionneur itératif à 4 entrées.
Les équations logiques associées à la cellule i du circuit itératif sont données par :
si = xi  yi  zi  wi  cin0i
ti = xiyi  xizi  xiwi  xicin0i  yizi  yiwi  yicin0i  ziwi  zicin0i  wicin0i
cout0i = ti  cin1i
cout1i = xiyiziwi  xiyizicin0i  xiyiwicin0i  xiziwicin0i  yiziwicin0i  ticin1i
On vous demande de compléter le code VHDL donné plus loin pour implémenter un additionneur séquen-
tiel série à n bits utilisant le module itératif et en vous basant sur le chemin de données suivant :
Figure 3 Chemin de données pour un additionneur sériel
library ieee;
entity serial_adder is
generic(data_width : integer := 8); -- largeur des données
port(
go : in std_logic; -- signal de début de traitement
Xi, Yi, Zi, Wi : in std_logic; -- bits des nombres sériels à additionner
valid : out std_logic; -- '1' lorsque la sortie S est valide
S : out std_logic -- résultat sériel de l'addition
);
end serial_adder;
architecture arch of serial_adder is
component cell_i is port(

xi, yi, zi, wi, cin0i, cin1i : in std_logic;
si, cout0i, cout1i : out std_logic
); end component;
signal si cin0i, cin1i : std_logic;

signal cout0i, cout1i : std_logic;
-- a) Déclaration de vos signaux

signal ready : boolean := true;
begin
u_iter : cell_i port map(Xi, Yi, Zi, Wi, cin0i, cin1i, si, cout0i, cout1i);
-- b) Votre implémentation
process(clk, rst) is
variable i : integer := -1;
begin
S <= '0'; valid <= '0';
cin0i <= '0'; cin1i <= '0';
ready <= true;
i := 0;
elsif( rising_edge( clk ) ) then
if ( ready = true ) then
if( go = '1' ) then
valid <= '1'; ready <= false;
i := i + 1; S <= si;
cin0i <= cout0i; cin1i <= cout1i;
else
i := -1; valid <= '0';
ready <= true; S <= '0';
cin0i <= '0'; cin1i <= '0';
end if;
else
if ( i = data_width-1 ) then
i := -1; valid <= '0';
ready <= true; S <= '0'; valid <= '0';
cin0i <= '0'; cin1i <= '0';
else
valid <= '1'; ready <= false;
i := i + 1; S <= si;
cin0i <= cout0i; cin1i <= cout1i;
end if;
end if;
end if;
end process;
end arch;
On considère un circuit qui réalise le contrôle d’une porte dont l’ouverture est commandée par un code
d’accès. Le code d’accès est saisi au moyen d’un clavier numérique, tel qu’illustré à la Figure 4.
Figure 4 Système d'ouverture de porte
Au départ, la porte est fermée. Pour l’ouvrir, l’usager doit entrer le symbole ‘*’, taper les quatre chiffres
de son code et terminer la saisie de son code par le symbole ‘’. Si le code est valide, le circuit maintient
une tension sur le signal ouverture qui force l’ouverture de la porte. Le circuit est réinitialisé lorsque la
porte est refermée, ce qui déclenche une impulsion sur le signal asynchrone rst.
a) (4 pts) Donnez un diagramme d’états pour le circuit séquentiel implémentant une machine à états
commandant cette porte.
Note : Les arcs non représentés mènent vers l’état Initial.
b) (4 pts) Donnez en VHDL une description possible d’un circuit séquentiel implémentant la ma-
chine à états décrite par votre diagramme d’états. L’entête du code VHDL que vous devez fournir
suit :
package symboles is
type symbole is ('#', '*', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9');
type code is array(0 to 3) of symbole;
end symboles;
library ieee;
use work.symboles.all;
entity ouverture_porte is
generic(
mon_code : code := ('1','8', '6','4')
);
port(
entree : in symbole; -- signal de début de traitement
ouverture : out std_logic -- signal ouvrant la porte
);
end ouverture_porte ;
architecture arch of ouverture_porte is
type state is (initial, saisie_debutee,

code_1, code_2, code_3, code_4,
saisie_confirmee);
signal etat_prochain : state := initial;

signal etat_actuel : state := initial;
begin
process(clk, rst) is
begin
etat_actuel <= initial;
etat_actuel <= etat_prochain;
end if;
end process;
ouverture <= '1' when etat_actuel = saisie_confirmee else '0';
process(etat_actuel, entree) is
begin
case( etat_actuel ) is
when initial =>
if ( entree = '*' ) then
etat_prochain <= saisie_debutee;
else
etat_prochain <= initial;
end if;
when saisie_debutee =>
elsif ( entree = mon_code( 0 ) ) then
else
end if;
when code_1 =>
elsif ( entree = mon_code( 1) ) then
else
end if;
when code_2 =>

else
end if;
when code_3 =>
else
end if;
when code_4 =>
elsif ( entree = '#' ) then
etat_prochain <= saisie_confirmee;
else
end if;
when saisie_confirmee =>
etat_prochain <= saisie_confirmee;
when others =>
end case;
end process;
end arch;
Questions brèves.
a) (1 pt) Donnez quatre fréquences d’horloge qu’il est possible de générer exactement à partir d’une hor-
loge de référence de 100 MHZ, telles que :
 la première soit entre 10 kHz et 500 kHz ; 100 MHz / 256 = 390.625 kHz
 la seconde entre 500 kHz et 1 MHz ; 100 MHz / 128 = 781.25 kHz
 la troisième entre 1 MH et 10 MHz et 100 MHz / 16 = 6.25 MHz
 la quatrième entre 10 MHz et 100 MHz. 100 MHz / 2 = 50 MHz
b) (1 pt) Considérez le processeur à usage spécifique et le processeur à usage général et donnez deux
avantage et deux inconvénient à chacune de ces options pour implémenter un algorithme de tri sur FPGA.
Vous pouvez utiliser l’exemple de la question 2 comme référence.
L’avantage d’un processeur général pour effectuer le tri et que l’algorithme est facile à implémenter et
que le programme est facilement modifiable. Cependant, la performance est limitée par le caractère sé-
quentiel de la tâche. Un processeur à usage spécifique comme celui de la question 2 permet d’atteindre
des gains de performance remarquable, mais sa structure est rigide, difficile à concevoir et à modifier.
c) (0.75 pt) Donnez quatre étapes importantes dans le flot de conception d’un circuit numérique sur
FPGA.
Synthèse, le placement, le routage et la simulation.
d) (0.75 pt) Discutez l’option d’utiliser un test pseudo-aléatoire pour tester une machine à états où le vec-
teur de test aléatoire alimente l’entrée du circuit séquentiel.
Une machine à états se doit d’être testée de manière exhaustive, c’est-à-dire en considérant à chaque état
toutes les combinaisons possibles. Un test aléatoire ne permet pas de faire ce genre de choses et rend le
test difficile à évaluer. Cette approche n’est pas recommandée pour une machine à états.
e) (0.75 pt) Donnez un exemple d’application où la latence initial d’une architecture à pipeline n’a aucun
impact sur la performance du système.
Par exemple, un circuit décodeur MP3 a une latence inhérente à son fonctionnement mais qui est imper-
ceptible à l’oreille humaine et n’a par conséquent aucun impact sur la performance.
f) (0.75 pt) Donnez un exemple d’application où la latence initial d’une architecture à pipeline a un im-
pact critique sur la performance du système.
La latence a un rôle critique s’il existe un chemin de rétroaction depuis la sortie vers l’entrée. Par exemple
dans l’implémentation matérielle d’un accumulateur.
Examen intra
Mercredi 16 juin 2010
Durée: 2h.
Pondération: 20%.
INF3500 – contrôle périodique – 16 juin 2010
En justifiant clairement vos réponses, indiquez pour chacun des énoncés VHDL suivants si l’opération est
synthétisable ou non. On supposera dans tous les cas que les signaux sig_1, sig_2 et sig_3 sont de type
unsigned et qu’ils sont correctement dimensionnés.
a) sig_3 <= sig_1 + sig_2;

b) sig_3 <= sig_1 / sig_2;
c) sig_3 <= sig_2 / 6;
d) sig_3 <= sig_2 mod 16;
e) sig_3 <= sig_1 * sig_2;
f) sig_3 <= sig_2 rem 3;
g) sig_3 <= 2*sig_2 + 6*sig_1;
h) sig_3 <= 6*(sig_1 – sig_2/16);
i) sig_3 <= 2.0*sig_2 + 6.0*sig_1;
j) sig_3 <= shift_left(sig_2, sig_1);
k) sig_3 <= shift_right(sig_2, 10.0);
l) sig_3 <= sig_2 ** 4;
m) sig_3 <= sig_2 ** 2.0;
n) sig_3 <= shift_left(sig_2, to_integer( sig_1 ) );
o) sig_3 <= sin( real( to_integer( sig_2 ) ) );
p) sig_3 <= to_unsigned( integer( sin( 3.14 ) * 2.0**8 ), 8 );
Considérez le code VHDL suivant, décrivant l’entité parite_paire, et le banc d’essai qui lui est associé.
L’entité parite_paire prend en entrée un vecteur de bits et produit un signal de parité tel que celui utili-
sé dans les systèmes de communication pour la détection et la correction d’erreurs.
Donnez les valeurs prises par la sortie dans l’exécution du banc d’essai sur un temps de simulation de
0.1 µs. Le temps de simulation débute au temps 0 s. On supposera que la réponse du circuit est instanta-
née (pas de délai de propagation des signaux d’entrée à la sortie).
library ieee;
entity parite_paire is
port (
din : in std_logic_vector(7 downto 0);
parite : out std_logic
);
end parite_paire;
architecture arch of parite_paire is

begin
process( din ) is
variable par : std_logic;
begin
par := din( 7 );
for k in 6 downto 0 loop
if din(k) = '1' then

par := not( par );
end if;
end loop;
parite <= par;
end process;
end arch;
library ieee;
entity parite_paire_tb is
end parite_paire_tb;
architecture behavior of parite_paire_tb is

component parite_paire
port( din : in std_logic_vector(7 downto 0);
parite : out std_logic );
end component;
signal din : std_logic_vector(7 downto 0) := (others => '0');
signal parite : std_logic;
begin
uut: parite_paire port map (din => din, parite => parite);
stim_proc: process
begin
wait for 10 ns;
din <= "10101011";
wait for 10 ns;
din <= "01011011";
wait for 10 ns;
din <= "10100001";
wait for 10 ns;
din <= "00110110";
end process;
end;
a) Donnez en VHDL une description possible du circuit suivant. L’entité prend en entrée le signal
d’horloge clk, un signal de réinitialisation rst (non représenté sur le schéma) et produit en sortie
le bit dout. L’initialisation doit être synchrone et mettre les bascules à l’état "0011".
b) À partir de l’état initial, donnez les 16 premières valeurs de la sortie dout.
a) Le code suivant comporte un certain nombre d’erreurs. La personne qui l’a écrit avait pour inten-
tion de décrire une machine de Moore classique. Rapportez quatre erreurs que vous constatez en
justifiant clairement vos réponses. Identifiez les erreurs que vous rapportez en indiquant le ou les
numéros de ligne de code qui leurs sont associés.
Attention, seules vos quatre premières réponses sont prises en compte !
1 library ieee;
2 use ieee.std_logic_1164.all;
3
4 entity mauvaiscodeur is
5 port (
6 reset : in std_logic;
7 clk : in std_logic;
8 a : in std_logic;
9 b : in std_logic;
10 c : out STD_LOGIC;
11 );
12 end mauvaiscodeur;
13
14 architecture arch of mauvaiscodeur is
15
16 type etats is (etat_A, etat_B, etat_C, etat_D);
17 signal etat_present : etat;
18 signal etat_prochain : etat;
19
20 begin
21
22 process(clk, reset) is
23 begin
24 if reset = '0' then
25 etat_present <= etat_A;
26 end if;
27
28 if rising_edge(clk) then
29 etat_present <= etat_prochain;
30 end if;
31
32 end process;
33
34 process(etat_present, a)
35 begin
36
37 if( etat_present = etat_A ) then
38 if( a = '1' ) then
39 etat_prochain <= etat_B;
40 elsif( b = '1' ) then
41 etat_prochain <= etat_C;
42 end if;
43 elsif( etat_present = etat_B ) then
44 etat_prochain <= etat_D;
45 else
46 etat_prochain <= etat_A;
47 end if;
48
49 end process;
50
51 process(etat_present)
52 begin
54 c <= '0';
55 end if;
56 end process;
57
58 end arch;
Considérez le code VHDL ci-après. Montrez, sur le diagramme qui suit un résultat possible de la synthèse
Remettez les deux feuilles dans votre cahier d’examen.
library ieee;
entity compte_2bits is
port (
clk : in std_logic;
en : in std_logic;
up : in std_logic;
so : out std_logic
);
end compte_2bits;
architecture arch of compte_2bits is
signal c : unsigned(1 downto 0) := "00";
begin
process( clk ) is
begin

if ( en = '1' ) then
if ( up = '1' ) then
c <= c + 1;
else
c <= c - 1;
end if;
end if;
end if;
end process;
process( c ) is
begin
if ( c = "11") then
so <= '1';
else
so <= '0';
end if;
end process;
end arch;
Annotez cette page et remettez-la avec votre cahier d’examen
Nom : ____________________________ Matricule : __________________________
Nom : ____________________________ Matricule : __________________________
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
Examen intra
Durée: 2h.
Pondération: 20%.
En justifiant clairement vos réponses, indiquez pour chacun des énoncés VHDL suivants si l’opération est
synthétisable ou non. On supposera dans tous les cas que les signaux sig_1, sig_2 et sig_3 sont de type
unsigned et qu’ils sont correctement dimensionnés.
a) sig_3 <= sig_1 + sig_2;

Énoncé synthétisable car il s’agit de l’addition de deux signaux de type unsigned.
b) sig_3 <= sig_1 / sig_2;
Énoncé non synthétisable car il s’agit de la division de deux signaux de type unsigned.
c) sig_3 <= sig_2 / 6;
Énoncé non synthétisable car il s’agit de la division d’un signal de type unsigned par une constante qui
n’est pas une puissance de 2.
d) sig_3 <= sig_2 mod 16;
Énoncé synthétisable car il s’agit d’une opération modulo puissance de 2 effectuée sur un signal de type
unsigned.
e) sig_3 <= sig_1 * sig_2;
Énoncé synthétisable car il s’agit de la multiplication de deux signaux de type unsigned.
f) sig_3 <= sig_2 rem 3;
Énoncé non synthétisable car il s’agit d’une operation « reste » d’un signal de type unsigned sur une cons-
tante qui n’est pas une puissance de 2.
g) sig_3 <= 2*sig_2 + 6*sig_1;
Énoncé synthétisable car il s’agit d’opérations de multiplications par une constante entière et d’addition
effectuées sur des signaux de type unsigned.
h) sig_3 <= 6*(sig_1 – sig_2/16);
Énoncé synthétisable. La division est opérée sur une constante puissance de deux. La soustraction est
effectuée sur des signaux de type unsigned. La multiplication par une constante entière est également
supportée.
i) sig_3 <= 2.0*sig_2 + 6.0*sig_1;
Énoncé non synthétisable. Bien que cet exemple ressemble à l’énoncé (g), les constantes sont de type real
ici et ne peuvent être synthétisées.
j) sig_3 <= shift_left(sig_2, sig_1);
Énoncé non synthétisable. Le second argument doit être de type integer.
k) sig_3 <= shift_right(sig_2, 10.0);
Énoncé non synthétisable. Le second argument doit être de type integer.
l) sig_3 <= sig_2 ** 4;
Énoncé non synthétisable car la puissance (même pas une puissance de 2) n’est pas synthétisable.
m) sig_3 <= sig_2 ** 2.0;

Énoncé non synthétisable car la puissance (même pas une puissance de 2) n’est pas synthétisable.
n) sig_3 <= shift_left(sig_2, to_integer( sig_1 ) );
Énoncé synthétisable car le second paramètre de la fonction shift_left est bien de type integer.
o) sig_3 <= sin( real( to_integer( sig_2 ) ) );
Énoncé non synthétisable car la fonction sinus ayant en paramètre un signal ne l’est pas.
p) sig_3 <= to_unsigned( integer( sin( 3.14 ) * 2.0**8 ), 8 );
Énoncé synthétisable. Nous avons ici l’initialisation d’un signal à une constante dont la valeur est définie
par la fonction sinus.
Considérez le code VHDL suivant, décrivant l’entité parite_paire, et le banc d’essai qui lui est associé.
L’entité parite_paire prend en entrée un vecteur de bits et produit un signal de parité tel que celui utili-
sé dans les systèmes de communication pour la détection et la correction d’erreurs.
Donnez les valeurs prises par la sortie dans l’exécution du banc d’essai sur un temps de simulation de
0.1 µs. Le temps de simulation débute au temps 0 s. On supposera que la réponse du circuit est instanta-
née (pas de délai de propagation des signaux d’entrée à la sortie).
library ieee;
entity parite_paire is
port (
din : in std_logic_vector(7 downto 0);
parite : out std_logic
);
end parite_paire;
architecture arch of parite_paire is

begin
process( din ) is
variable par : std_logic;
begin
par := din( 7 );
if din(k) = '1' then

par := not( par );
end if;
end loop;
parite <= par;
end process;
end arch;
library ieee;
entity parite_paire_tb is
end parite_paire_tb;
architecture behavior of parite_paire_tb is

component parite_paire
port( din : in std_logic_vector(7 downto 0);
parite : out std_logic );
end component;
signal din : std_logic_vector(7 downto 0) := (others => '0');
signal parite : std_logic;
begin
uut: parite_paire port map (din => din, parite => parite);
stim_proc: process
begin
wait for 10 ns;

din <= "10101011";
wait for 10 ns;
din <= "01011011";
wait for 10 ns;
din <= "10100001";
wait for 10 ns;
din <= "00110110";
end process;
end;
Solution :
Le signal parite vaut 1 si le nombre bits valant 1 dans din est impair ; autrement, parite vaut 0. Le tableau
qui suit donne les intervalles de temps, la valeur de din correspondante et la valeur de parite qui lui est
associée.
Intervalle de temps din parite
0 – 10 ns "00000000" ‘0’
10 ns – 20 ns "10101011" ‘1’
20 ns – 30 ns "01011011" ‘1’
30 ns – 40 ns "10100001" ‘1’
40 ns – 50 ns "00111110" ‘0’
50 ns – 60 ns "10101011" ‘1’
60 ns – 70 ns "01011011" ‘1’
70 ns – 80 ns "10100001" ‘1’
80 ns – 90 ns "00110110" ‘0’
90 ns – 100 ns "10101011" ‘1’
a) Donnez en VHDL une description possible du circuit suivant. L’entité prend en entrée le signal
d’horloge clk, un signal de réinitialisation rst (non représenté sur le schéma) et produit en sortie
le bit dout. L’initialisation doit être synchrone et mettre les bascules à l’état "0011".
Solution possible:
library ieee;
entity lfsr4bits is
port(
clk : in std_logic;
rst : in std_logic;
dout : out std_logic
);
end lfsr4bits;
architecture arch of lfsr4bits is

begin
process( clk )
variable reg : std_logic_vector(3 downto 0) := "0011";
begin
if ( rst = '1' ) then
reg := "0011";
else
reg := (reg(1) xor reg(0)) & reg(3 downto 1);
end if;
end if;
dout <= reg(0);
end process;
end arch;
b) À partir de l’état initial, donnez les 16 premières valeurs de la sortie dout.

‘1’, ‘1’, ‘0’, ‘0’, ‘0’, ‘1’, ‘0’, ‘0’, ‘1’, ‘1’, ‘0’, ‘1’, ‘0’, ‘1’, ‘1’, ‘1’
a) Le code suivant comporte un certain nombre d’erreurs. La personne qui l’a écrit avait pour inten-
tion de décrire une machine de Moore classique. Rapportez quatre erreurs que vous constatez en
justifiant clairement vos réponses. Identifiez les erreurs que vous rapportez en indiquant le ou les
numéros de ligne de code qui leurs sont associés.
Attention, seules vos quatre premières réponses sont prises en compte !
1 library ieee;
2 use ieee.std_logic_1164.all;
3
4 entity mauvaiscodeur is
5 port (
6 reset : in std_logic;
7 clk : in std_logic;
8 a : in std_logic;
9 b : in std_logic;
11 );
12 end mauvaiscodeur;
13
14 architecture arch of mauvaiscodeur is
15
16 type etats is (etat_A, etat_B, etat_C, etat_D);
17 signal etat_present : etat;
18 signal etat_prochain : etat;
19
20 begin
21
22 process(clk, reset) is
23 begin
24 if reset = '0' then
25 etat_present <= etat_A;
26 end if;
27
29 etat_present <= etat_prochain;
30 end if;
31
32 end process;
33
35 begin
36
38 if( a = '1' ) then
42 end if;
43 elsif( etat_present = etat_B ) then
44 etat_prochain <= etat_D;
45 else
46 etat_prochain <= etat_A;
47 end if;
48
49 end process;
50
51 process(etat_present)
52 begin
54 c <= '0';
55 end if;
56 end process;
57
58 end arch;
Solution :
 Ligne 10 :
Le point-virgule final est de trop.

 Lignes 26-28 :
26 end if;
27
Le bloc de IF de l’initialisation doit être lié à celui du front montant de l’horloge.

 Lignes 34 :
La liste de sensibilité est incomplète — il manque l’entrée b.

 Lignes 38-42 :
38 if( a = '1' ) then
42 end if;
Tous les cas ne sont pas couvert ce qui cause l’introduction d’un loquet indésirable.
 Lignes 53-55 :
54 c <= '0';
55 end if;
Tous les cas ne sont pas couvert ce qui cause l’introduction d’un loquet indésirable.
Considérez le code VHDL ci-après. Montrez, sur le diagramme qui suit un résultat possible de la synthèse
library ieee;
entity compte_2bits is
port (
clk : in std_logic;
en : in std_logic;
up : in std_logic;
so : out std_logic
);
end compte_2bits;
architecture arch of compte_2bits is
signal c : unsigned(1 downto 0) := "00";
begin
process( clk ) is
begin

if ( en = '1' ) then
if ( up = '1' ) then
c <= c + 1;
else
c <= c - 1;
end if;
end if;
end if;
end process;
process( c ) is
begin
if ( c = "11") then
so <= '1';
else
so <= '0';
end if;
end process;
end arch;
Nom : ____________________________ Matricule : __________________________
G4
en YQ c(1)
G3 D Q
up Table de
conversion
G2 G CLK
16 X 1 S0
G1
H1 S1
F4
en XQ c(0)
F3 D Q
up Table de
conversion
F2 F CLK
16 X 1 S2
F1
S3
CLK
G4
YQ
G3 D Q
Table de
conversion
G2 G CLK
16 X 1 S0
G1
Y
0 so
H
1
H1 S1
F4
XQ
F3 D Q
Table de
conversion
F2 F CLK
16 X 1 S2
F1
S3
CLK
Le signal d’initialisation (rst) est directement connecté aux bascules. Le signal de charge (en) aurait pu
l’être aussi.
Nom : ____________________________ Matricule : __________________________
G4 G3 G2 G1 G F4 F3 F2 F1 F
(en) (up) (c(1)) (c(0)) (c(1)) (en) (up) (c(1)) (c(0)) (c(1))
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 1 1
0 0 1 0 1 0 0 1 0 0
0 0 1 1 1 0 0 1 1 1
0 1 0 0 0 0 1 0 0 0
0 1 0 1 0 0 1 0 1 1
0 1 1 0 1 0 1 1 0 0
0 1 1 1 1 0 1 1 1 1
1 0 0 0 1 1 0 0 0 1
1 0 0 1 0 1 0 0 1 0
1 0 1 0 0 1 0 1 0 1
1 0 1 1 1 1 0 1 1 0
1 1 0 0 0 1 1 0 0 1
1 1 0 1 1 1 1 0 1 0
1 1 1 0 1 1 1 1 0 1
1 1 1 1 0 1 1 1 1 0
G4 G3 G2 G1 G F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
(c(0)) (c(1)) (nc) (nc) (so)
0 0 0 0
0 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 1 0
0 0 1 0 0 0 0 1 1
0 0 1 1 0 0 1 0 0
0 1 0 0 0 0 1 0 1
0 1 0 1 0 0 1 1 0
0 1 1 0 0 0 1 1 1
0 1 1 1 0 1 0 0 0
1 0 0 0 0 1 0 0 1
1 0 0 1 0 1 0 1 0
1 0 1 0 0 1 0 1 1
1 0 1 1 0 1 1 0 0
1 1 0 0 1 1 1 0 1
1 1 0 1 1 1 1 1 0
1 1 1 0 1 1 1 1 1
1 1 1 1 1
Examen final
Avril 2010
Durée: 2h30.
Pondération: 40%.
• Ordinateurs interdits.
• Répondre dans le cahier fourni.
• Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute sup-
INF3500 – examen final – hiver 2010
Considérez le problème de la conception d’un multiplicateur complexe.

Les entrées du circuit sont A, B, C, D, représentant les nombres Z1 = A + jB et Z2 = C + jD. Les sorties du
circuit sont E et F représentant Z3 = E + jF, avec Z3 = Z1 × Z2. Les entrées sont des nombres entiers signés
exprimés avec 16 bits. Le multiplicateur doit être implémenté sur un FPGA.
a. Faites la conception d’un multiplicateur complexe qui maximise le débit des calculs. Donnez un dia-
gramme du chemin des données de votre circuit, et, si nécessaire, le diagramme d’états de l’unité de
contrôle. Ne donnez pas de code VHDL.
b. Faites la conception d’un multiplicateur complexe qui minimise la surface utilisée. Donnez un dia-
gramme du chemin des données de votre circuit, et, si nécessaire, le diagramme d’états de l’unité de
contrôle. Ne donnez pas de code VHDL.
Solution :
a.
b.
"
L’algorithme ELA (Edge-based Line Average) a pour but de doubler la résolution verticale d’une image.
La figure montre les pixels impliqués dans les calculs. L’algorithme accepte en entrée les six pixels A, B,
C, D, E et F, et produit en sortie le pixel P. Il calcule trois différences absolues : |A – F|, |B – E| et |C – D|.
La plus petite de ces trois valeurs indique la direction d’interpolation. La valeur de P est alors donnée par
la moyenne des deux pixels le long de la direction d’interpolation. Par exemple, si |A – F| a la plus petite
valeur, alors P = (A + F) / 2. La valeur de tous les pixels est représentée en tons de gris sur 8 bits.
Donnez une architecture pour l’entité suivante en VHDL synthétisable, afin de réaliser l’algorithme ELA
tout en maximisant le débit.
library ieee;
entity ELA is
port (
A, B, C, D, E, F: in unsigned(7 downto 0);
P: out unsigned (7 downto 0)
);
end ELA;
Solution :
architecture arch of ELA is
begin
process(A, B, C, D, E, F)
variable A9, B9, C9, D9, E9, F9: unsigned(8 downto 0); -- pixels expimés sur 9 bits
variable D1, D2, D3: unsigned(7 downto 0); -- trois différences
variable I1, I2, I3: unsigned(7 downto 0); -- trois interpolations
begin
-- on exprime la valeur des pixels sur 9 bits de façon à éviter les

-- débordements dans les calculs
A9 := resize(A, 9); B9 := resize(B, 9); C9 := resize(C, 9);
D9 := resize(D, 9); E9 := resize(E, 9); F9 := resize(F, 9);
-- pour les trois différences, il faut passer au type signed parce que la
-- différence peut être négative avant de prendre sa valeur absolue
D1 := resize(unsigned(abs(signed(A9) - signed(F9))), 8);
D2 := resize(unsigned(abs(signed(B9) - signed(E9))), 8);
D3 := resize(unsigned(abs(signed(C9) - signed(D9))), 8);
-- pour les trois interpolations, il faut:

-- 1. faire l'addition sur 9 bits (p. ex., 128 + 128 = 256 nécessite 9 bits)
-- 2. diviser par deux
-- 3. exprimer le résultat sur 8 bits
I1 := resize((A9 + F9) / 2, 8);
I2 := resize((B9 + E9) / 2, 8);
I3 := resize((C9 + D9) / 2, 8);
if (D1 <= D2 and D1 <= D3) then

P <= I1;
elsif (D2 <= D1 and D2 <= D3) then
P <= I2;
else
P <= I3;
end if;
end process;
end arch;
Faites la conception d’un processeur pour un télémètre laser. Le télémètre a un bouton pour déclencher la
prise de mesure. Quand le bouton est pressé, une impulsion lumineuse est générée et un chronomètre est
activé. L’impulsion lumineuse se propage dans l’air, frappe la cible et revient vers un détecteur. Quand
l’écho de l’impulsion lumineuse est perçu par le détecteur, le chronomètre est arrêté et la distance peut
être calculée en tenant compte de la vitesse de propagation de la lumière dans l’air. Soit T le temps mesu-
ré par le chronomètre, en secondes, alors la distance D est donnée par D = T × c / 2, où c = 3 × 108 m/s.
Le processeur a deux entrées : le bouton et un signal provenant du détecteur indiquant qu’une impulsion
lumineuse a été reçue. Il a deux sorties : un signal vers le laser pour déclencher une impulsion lumineuse
et un autre signal indiquant la distance mesurée.
a. Donnez un diagramme représentant le chemin des données du processeur.
c. Donnez la précision du télémètre laser en fonction de la fréquence d’horloge du circuit et sa portée
maximale en fonction de la taille du chronomètre.
Solution :
a.
% %
&'
&' "
#$ #$
"
b.
c.
T × 3 × 10 8 m / s Par exemple, pour f_CLK = 150 MHz, on a cons-

D= tante = 1 m et donc chaque incrément du compteur
2 correspond à un mètre de distance de la cible. La
compteur constante est donc la résolution du système.
T = compteur × période _ CLK =
f _ CLK
compteur × 3 ×10 8 m / s La valeur maximale du compteur détermine la
D=
2 × f _ CLK distance maximale. Par exemple, pour un compteur
de 10 bits et f_CLK = 150 MHz, la distance maxi-
3 × 10 8 m / s male serait 1023 m.
constante =
2 × f _ CLK
library IEEE; library ieee;
use IEEE.std_logic_1164.all; use ieee.std_logic_1164.all;
entity module3 is entity module3_TB is

port ( end module3_TB;
F, G : out std_logic architecture arch of module3_TB is
); signal A, B, C, F, G : std_logic;
end module3; begin
architecture arch of module3 is UUT : entity module3(arch) port map

signal S, T, U : std_logic; (A, B, C, F, G);
begin
A <= '1' after 0 ns;
S <= A or B; B <= '0' after 0 ns;
T <= A xor B; C <= '0' after 0 ns, '1' after 10 ns;
U <= A and C;
end arch;
process (S, T)
begin
F <= S and T and C;
end process;
process (B, U)
begin
G <= B or U;
end process;
end arch;
a. Donnez la liste des événements, telle qu’elle pourrait être dressée par un simulateur qui exécuterait le
banc d’essai.
b. En vous basant sur votre liste des événements, donnez la valeur de tous les ports et signaux internes du
module combinatoire en fonction du temps, en tenant compte des délais deltas.
Solution :
À t = 0 + 0 , initialisation de la simulation (tout à ‘U’)
À t = 0 + 1 , assignation de 100 à (A, B, C)
À t = 0 + 2 , évaluation des signaux S, T, U et G (provoquées par les changements sur A, B, C)
À t = 0 + 3 , évaluation de F et G (provoquées par les changements sur S, T, U)
À t = 10 ns + 0 , assignation de 1 à C
À t = 10 ns + 1 , évaluation de U (provoquée par le changement sur C), ** mais pas d’évaluation de F
parce que C n’est pas dans la liste de sensitivité du processus **
À t = 10 ns + 2 , évaluation de G (provoquée par le changement sur U)
b.
Considérez le code VHDL suivant.

a. Donnez un diagramme correspondant composé de modules combinatoires (multiplexeurs, décodeurs,
etc.), d’unités fonctionnelles (additionneurs, multiplicateurs, comparateurs, etc.) et d’éléments à mémoire
tel qu’il pourrait être généré par un processus de synthèse.
b. Estimez le nombre de ressources nécessaires, en termes de LUTs et de bascules, pour implémenter ce
circuit sur le FPGA utilisé dans les laboratoires du cours. Justifiez complètement votre réponse.
library ieee;
entity compteurSecondes is
port (
reset_n, clk1Hz : in std_logic;
secondes : out unsigned(5 downto 0);
uneminute : out std_logic
);
end compteurSecondes;
architecture arch of compteurSecondes is

signal secondes_t : natural range 0 to 59;
begin
secondes <= to_unsigned(secondes_t, secondes'length);
process(clk1Hz) is
begin
if rising_edge(clk1Hz) then
secondes_t <= 0;
uneminute <= '0';
else
if secondes_t = 59 then
secondes_t <= 0;
uneminute <= '1';
else
secondes_t <= secondes_t + 1;
uneminute <= '0';
end if;
end if;
end if;
end process;
end arch;
Solution :
a.
" ( ")
* % * " ("
+ +
#$
,-.
% &
#$
b.
Il y a un total de 7 bascules.
Pour les LUTs, une analyse de base procède comme suit. L’additionneur à 6 bits nécessite 6 LUTs (un par
bit). Le bloc de comparaison d’égalité nécessite 6 LUTs (un par bit). Le multiplexeur à deux entrées de 6
bits nécessite 6 LUTs.
Le total serait donc de 7 bascules et 18 LUTs.
{Dans les faits, une analyse des résultats de synthèse révèle que le bloc de comparaison et le multiplexeur
peuvent être combinés en 5 bascules seulement. Ceci s’explique entre autres parce que les LUTs peuvent
avoir jusqu’à 4 entrées. Avec les 6 LUTs de l’additionneur, au total 7 bascules et 11 LUTs sont nécessai-
res.}
Réponses brèves.
a. On vous propose de participer au développement d’un nouveau langage de description matérielle, Po-
lyHDL. Ce langage devra servir à modéliser des circuits numériques qui seront implémentés sur FPGA.
Donnez quatre caractéristiques que vous considérez essentielles pour ce langage.
Solution : pouvoir représenter la concurrence, pouvoir modéliser des composantes matérielles, permettre
la simulation du modèle, permettre la synthèse du modèle, inclure des opérateurs correspondant à des
structures disponibles sur FPGA, permettre la description de bancs d’essais, favoriser l’abstraction et la
hiérarchie, etc.
b. Énumérez deux stratégies à suivre pour choisir des vecteurs de test afin de vérifier un circuit numéri-
que.
Solutions possibles : Analyse des valeurs limites, partitionnement en classes, cas spéciaux choisis ma-
nuellement, valeurs pseudo-aléatoires. Pour la moitié des points : tests de boîte noire, tests de boîte blan-
che, couverture de code, couverture de branchements, etc.
c. Expliquez comment un double tampon peut permettre de synchroniser l’échange d’informations entre
deux domaines d’horloge différents.
Solution : Un double tampon consiste de deux bascules en série. L’entrée asynchrone est appliquée à la
première bascule. Il est possible que celle-ci entre dans un état métastable. Elle finira en pratique par se
stabiliser sur un 1 ou un 0. La deuxième bascule permet d’accorder le plus long temps possible à la pre-
mière bascule pour se stabiliser, soit une période d’horloge.
d. Expliquez pourquoi la division générale n’est pas synthétisable par la plupart des synthétiseurs de code
HDL ciblant des FPGA.
Solutions : La division générale n’est pas synthétisable par choix des concepteurs de synthétiseurs. Puis-
que les FPGA ne possèdent pas de bloc implémentant la division, il faudrait choisir une architecture de
diviseur en particulier et la réaliser avec un arrangement de LUT, FF, etc. Les concepteurs de synthéti-
seurs préfèrent laisser ce choix aux concepteurs de systèmes numériques qui écrivent du code HDL.
e. Énumérez deux principes à suivre pour la conception et l’implémentation de circuits numériques sur
FPGAs.
Quelques solutions possibles : conception synchrone, ne pas utiliser de loquets, signal d’initialisation
global, routage spécial du signal d’horloge, exploitation de toutes les ressources de la puce, gestion ma-
nuelle de la disposition, arithmétique en virgule fixe plutôt que flottante.
f. En VHDL, les attributs permettent d’obtenir de l’information à propos de types, signaux, variables et
constantes. Donnez deux exemples d’attributs en VHDL.
Solution possibles: ‘left, ‘right, ‘low, ‘high, ‘range, ‘length, ‘image, ‘value, ‘event, etc.
Examen intra
Vendredi 19 février 2010
Durée: 2h.
Pondération: 20%.
• Répondre dans le cahier fourni et soumettre la page du questionnaire indiquée.
• Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute
INF3500 – contrôle périodique – 19 février 2010
a.
library ieee;
-- La sortie de ce compteur est remise à zéro de façon synchrone quand reset = '1'.
-- Le compteur est incrémenté par la valeur 'delta' à chaque coup d'horloge.
entity compteurSpecial is
generic (
W : positive := 5
);
port (
delta : in unsigned(W - 1 downto 0);
compte : out unsigned(W - 1 downto 0)
);
end compteurSpecial;

architecture arch of compteurSpecial is
begin
process(clk, reset)
variable c : unsigned(W - 1 downto 0);
begin
if reset = '1' then
c := (others => '0');
else
c := c + delta;
end if;
end if;
compte <= c;
end process;
end arch;
b.
library ieee;
-- Ce registre est remis à zéro de façon asynchrone quand reset = '1'.

-- La valeur du port D est chargée sur une transition positive d'horloge
-- quand charge = '1'. Si charge = '0' et que div2 = '1', alors le contenu
-- du registre est décalé d'une position vers la droite sur une transition
-- positive d'horloge.
entity registre is
generic (
W : integer := 8 -- nombre de bits du registre
);
port (
reset, clk, charge, div2 : in std_logic;
D : in unsigned(W - 1 downto 0);
Q : out unsigned(W - 1 downto 0)
);
end registre;

architecture arch of registre is
begin
process (CLK, reset)
variable Qt : unsigned(W - 1 downto 0);
begin
if reset = '1' then
Qt := (others => '0');
if charge = '1' then
Qt := D;
elsif div2 = '1' then
Qt := '0' & Qt(W - 1 downto 1);
end if;
end if;
Q <= Qt;
end process;
end arch;
Donnez un diagramme d’un chemin des données implémentant les micro-opérations suivantes.
a. K2: S ← (S + A * B) / 8;
b. K1’K0’: S ← S – 100; K1’K0: S ← S – 25; K1K0’: S ← S – 10; K1K0: S ← S – 5;

Considérez le code VHDL suivant. Le circuit accepte en entrée un nombre non signé encodé sur 8 bits. Il
donne une approximation du logarithme à base 2 du nombre. Si le nombre est égal à 0, un signal spécial
d’erreur est activé.
library IEEE;
entity log2approx is
port (
N : in unsigned(7 downto 0);
log2N : out unsigned(10 downto 0);
);
end log2approx;
architecture arch of log2approx is

signal partieentiere : integer range 0 to 7 := 0;
signal partiefract : unsigned(7 downto 0) := (others => '0');
begin
process(N)
begin
erreur <= '1';
partieentiere <= 0;
if N(k) = '1' then
partieentiere <= k;
erreur <= '0';
exit;
end if;
end loop;
end process;
partiefract <= shift_left(N, 8 - partieentiere);
log2N <= to_unsigned(partieentiere, 3) & partiefract;
end arch;
Solution :
V erreur
encodeur à priorité
N / D
8 8:3 A / ~log2(N)
3
compte
décaleur - gauche /
8
Pour l’entité log2approx décrite à la question précédente, composez un banc d’essai qui effectue une
stimulation exhaustive, puis qui rapporte la différence maximale et la différence moyenne entre
l’approximation générée par le module et la valeur exacte du logarithme. Le banc de test doit aussi véri-
fier si le bit d’erreur fonctionne correctement.
Rappel : Le package math_real inclut une fonction log2() qui prend en paramètre un réel et qui retourne
son logarithme en base 2 sous la forme d’un réel.
library ieee;
use ieee.NUMERIC_STD.all;
entity log2approx_tb is
end log2approx_tb;
architecture TB_ARCHITECTURE of log2approx_tb is

--- votre code ici
begin
--- votre code ici

architecture TB_ARCHITECTURE of log2approx_tb is
signal N : UNSIGNED(7 downto 0);

signal log2N : UNSIGNED(10 downto 0);
signal erreur : STD_LOGIC;
begin
UUT : entity log2approx(arch) port map (N, log2N, erreur);
process
variable log2N_vrai, difference, diffmax, sommediff : real;
begin
diffmax := 0.0;
sommediff := 0.0;
N <= to_unsigned(k, N'length);
wait for 10 ns;
if k = 0 then
assert erreur = '1' report "bit d'erreur incorrect pour N = 0!"
severity failure;
else
assert erreur = '0' report "bit d'erreur incorrect pour N > 0!"
severity failure;
log2N_vrai := log2(real(to_integer(N)));
difference := abs(real(to_integer(log2N)) / (2.0 ** 8) - log2N_vrai);
if difference > diffmax then
diffmax := difference;
end if;
sommediff := sommediff + difference;
report "N: " & integer'image(to_integer(N)) &

", log2N: " & real'image(real(to_integer(log2N)) / (2.0 ** 8)) &
", log2N_vrai: " & real'image(log2N_vrai) &
", difference: " & real'image(difference);
end if;
end loop;
report "différence maximale: " & real'image(diffmax);
report "différence moyenne: " & real'image(sommediff / 255.0);
end process;
Réponses brèves.
a. Lequel des énoncés suivants est vrai concernant des entités et architectures en VHDL?
iv. un module peut avoir plusieurs déclarations d’entité et plusieurs architectures;
Solution : ii. Une entité, plusieurs architectures
b. Il y a quatre catégories d’objets en VHDL, dont signal et file. Quelles sont les deux autres?
Solution : variable et constant
c. L’architecture d’un certain modèle VHDL contient exclusivement des assignations de signaux concur-
rentes, choisies et conditionnelles. Avec quel style de description de circuit ce modèle est-il décrit?
Solution : flot de données
d. Lequel/lesquels des énoncés suivants est/sont vrai(s) concernant VHDL?
cessus.
Solution : i, iii, iv, v.
e. Énumérez quatre (4) éléments qu’on peut retrouver sur un FPGA présentement en vente sur le marché,
à part des blocs de logique programmable (CLB) et de leur contenu.
Solution : blocs d’entrées-sorties (IOB), réseau d’interconnexions, circuits de routage rapide des retenues,
blocs de mémoire intégrée, blocs de fonctions arithmétiques avancées (multiplicateurs, multiplicateurs-
accumulateurs), microprocesseurs fixes, circuits de génération et de distribution d’horloge.
f. Énumérez deux des composantes fondamentales qu’on peut retrouver à l’intérieur d’un circuit logique
programmable complexe (CPLD) présentement en vente sur le marché.
Solution : blocs fonctionnels (effectivement des PALs), macrocellules (contenant un élément à mémoire
programmable), cellules d’entrées-sorties et réseau d’interconnexions
Considérez le code VHDL suivant. Montrez, sur le diagramme suivant d’une partie d’un FPGA, un résul-
tat possible de la synthèse et de l’implémentation de ce code. Indiquez directement sur le dessin où cha-
library IEEE;
entity module2 is
port (
CLK, A, B, C, D, E : in std_logic;
F : out std_logic
);
end module2;
architecture arch of module2 is

signal S : std_logic_vector(1 downto 0);
begin
process (CLK)
begin
S(0) <= A or B or C or D;
S(1) <= A and B and not(E);
end if;
end process;
process (S, A, C, D)
begin
if S(0) = '1' then
F <= A or not(D);
else
F <= S(1) or C or D;
end if;
end process;
end arch;
Nom : ____________________________ Matricule : __________________________
Nom : ____________________________ Matricule : __________________________
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
Solution :
G4
A YQ S(0)
G3 D Q
B Table de
conversion
G2 G CLK
C 16 X 1 S0
G!
D
Y
H1 S1
F4
A XQ S(1)
F3 D Q
B Table de
conversion
F2 F CLK
E 16 X 1 S2
F1
S3
CLK
G4
YQ
G3 D Q
C Table de
conversion
G2 G CLK
D 16 X 1 S0
G!
Y
0 F
H
1
H1 S1
F4
A XQ
F3 D Q
D Table de
conversion
F2 F CLK
16 X 1 S2
F1
S3
CLK
G4 G3 G2 G1 G F4 F3 F2 F1 F
(A ) (B ) (C ) (D ) (S(0)) (A ) (B ) (E ) (NC ) (S(1))
0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 1 0
0 0 1 0 1 0 0 1 0 0
0 0 1 1 1 0 0 1 1 0
0 1 0 0 1 0 1 0 0 0
0 1 0 1 1 0 1 0 1 0
0 1 1 0 1 0 1 1 0 0
0 1 1 1 1 0 1 1 1 0
1 0 0 0 1 1 0 0 0 0
1 0 0 1 1 1 0 0 1 0
1 0 1 0 1 1 0 1 0 0
1 0 1 1 1 1 0 1 1 0
1 1 0 0 1 1 1 0 0 1
1 1 0 1 1 1 1 0 1 1
1 1 1 0 1 1 1 1 0 0
1 1 1 1 1 1 1 1 1 0
G4 G3 G2 G1 F4 F3 F2 F1
G() F()
(S(1)) (C) (D) (NC) (A) (D) (NC) (NC)
0 0 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 0 1 1
0 0 1 0 1 0 0 1 0 1
0 0 1 1 1 0 0 1 1 1
0 1 0 0 1 0 1 0 0 0
0 1 0 1 1 0 1 0 1 0
0 1 1 0 1 0 1 1 0 0
0 1 1 1 1 0 1 1 1 0
1 0 0 0 1 1 0 0 0 1
1 0 0 1 1 1 0 0 1 1
1 0 1 0 1 1 0 1 0 1
1 0 1 1 1 1 0 1 1 1
1 1 0 0 1 1 1 0 0 1
1 1 0 1 1 1 1 0 1 1
1 1 1 0 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1

Examen final
Décembre 2011
Durée: 2h30.
Pondération: 40%.
 Répondre dans le cahier fourni.
 Ne pas remettre le questionnaire, sauf la dernière page qui doit être annotée et remise.
 Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute sup-
Considérez le diagramme suivant pour un circuit numérique qui accepte en entrée trois nombres signés A,
B, et C exprimés avec W bits et qui a pour sortie la médiane des trois nombres. Dans une liste de nom-
bres, la médiane est au milieu de la liste classée par ordre de grandeur. Par exemple, la médiane de {10, -
1, 7} est 7. La médiane de {15, 12, 12} est 12.
Dans le diagramme, le bloc S > T donne une sortie de ‘1’ quand l’entrée S est plus grande que l’entrée T,
et ‘0’ dans le cas contraire. Le multiplexeur à huit entrées est contrôlé par les sorties des blocs S > T. Les
tirets ‘-‘ indiquent des entrées sans importance (‘dont’ care’).
Donnez une architecture en VHDL correspondant à cette entité et à ce diagramme.
B 0 library IEEE;
A S
C 1 use IEEE.std_logic_1164.all;
- 2
A
S>T
3
lamediane entity mediane is
A 4
generic (
- 5
B T C 6
W : positive := 16
S0
B 7
S2
S1
);
port (
A S );
end mediane;
S>T
C T
B S
S>T
Toutes les lignes sont des bus de
C T W bits, sauf les lignes de contrôle
du multiplexeur.
Donnez une architecture pour l’entité suivante en VHDL synthétisable, en respectant les spécifications
données en commentaires.
library ieee;
-- Ce compteur a le comportement suivant.

-- Le compte s'effectue sur une transition négative du signal d'horloge.
-- Le compte est activé quand go == '1'.
-- Le signal UD détermine si le compte est vers le haut ('1') ou vers le bas ('0').
-- Le compte est remis à zéro de façon asynchrone quand reset = '1';
entity compteurUD is
generic (W : integer := 8);
port (
clk, reset, go, UD : in std_logic;
compte : out signed(W - 1 downto 0)
);
end compteurUD;
Considérez le code VHDL suivant pour un arbitre de bus rudimentaire.

Donnez un schéma du circuit correspondant à ce code.
library ieee;
entity arbitreBus is
generic (n : positive := 2);
port(
requetes : in std_logic_vector(2 ** n - 1 downto 0);
donneesIn : in std_logic_vector(2 ** n - 1 downto 0);
donneeOut, donneeValide : out std_logic
);
end arbitreBus;
architecture arch of arbitreBus is

signal choix : unsigned(n - 1 downto 0);
begin
process(requetes, donneesIn)
begin
for k in 2 ** n - 1 downto 0 loop
if requetes(k) = '1' then
choix <= to_unsigned(k, n);
exit;
end if;
end loop;
end process;
process(choix, donneesIn)
begin
donneeOut <= donneesIn(to_integer(choix));
end process;
end arch;
Faites la conception d’un circuit numérique combinatoire qui accepte en entrée un vecteur de 8 bits repré-
sentant un nombre positif de secondes. Votre circuit doit avoir deux sorties binaires donnant le nombre de
minutes et secondes correspondantes. Donnez un diagramme de votre circuit, ne donnez pas de code
VHDL. Indiquez la largeur des ports de sortie en bits. Vous pouvez utiliser des opérations logiques et
arithmétiques (mais pas la division ni le modulo), la comparaison, des multiplexeurs, décodeurs et enco-
deurs, et toute autre porte logique de base. Votre circuit doit être purement combinatoire, il ne doit pas
library IEEE; library ieee;

use IEEE.std_logic_1164.all; use ieee.std_logic_1164.all;
entity module3 is entity module3_TB is

port ( end module3_TB;
F, G : out std_logic architecture arch of module3_TB is
); signal A, B, C, F, G : std_logic;
end module3; begin
architecture arch of module3 is UUT : entity module3(arch) port map

signal S, T, U : std_logic; (A, B, C, F, G);
begin
S <= A or B; B <= '0' after 0 ns;
T <= A xor B; C <= '0' after 0 ns, '1' after 10 ns;
U <= A and C;
end arch;
process (S, T)
begin
F <= S and T and C;
end process;
process (B, U)
begin
G <= B or U;
end process;
end arch;
a. (4 points) Donnez la liste des événements, telle qu’elle pourrait être dressée par un simulateur qui exé-
cuterait le banc d’essai.
b. (4 points) En vous basant sur votre liste des événements, donnez la valeur de tous les ports et signaux
internes du module combinatoire en fonction du temps, en tenant compte des délais deltas.
Considérez le diagramme de la page suivante montrant un circuit implémenté sur un FPGA simplifié. Les
entrées du circuit sont les signaux A, B, C, D, E et F. Il y a deux sorties P et Q. Le FPGA est composé de
tranches ayant chacune une table de correspondance (LUT) et une bascule pouvant être utilisée ou non, et
de blocs d’entrée/sortie (IOB) dans lesquels les bascules sont toujours utilisées.
Pour ce FPGA, les LUTs ont un délai de 2.25 ns. Les bascules ont un délai de 0.75 ns, un temps de prépa-
ration tsu de 0.25 ns, et un temps de maintien th de 0.1 ns. Les interconnexions entre les rangées de tran-
ches et entre les IOB et les tranches ont un délai de 0.2 ns.
a. (2 points) Identifiez le chemin critique du circuit et donnez la fréquence maximale d’horloge.
b. (1 point) Donnez la latence du circuit en secondes.
c. (3 points) On désire atteindre un débit minimal de 165 × 106 résultats par seconde, où un résultat est
une paire (P, Q). Expliquez comment faire pour atteindre ce niveau de performance. Justifiez complète-
ment votre approche.
d. (1 point) Donnez la latence du circuit modifié selon votre approche décrite en c. en secondes.
e. (2 points) On désire atteindre un débit minimal de 550 × 106 résultats par seconde, où un résultat est
une paire (P, Q). Est-ce possible? Si oui, expliquez comment faire. Sinon, expliquez pourquoi.
f. (1 point) Pour ce FPGA, donnez la fréquence maximale d’horloge qu’un circuit pourrait atteindre. Ex-
pliquez votre réponse.
Question 6

Solutionnaire d’examen final
Décembre 2011
Solutions
Q1 Solution:
architecture arch of mediane is Il y a une multitude de solutions acceptables. On peut

signal ApgB : std_logic := '0';
signal ApgC : std_logic := '0';
aussi imaginer d’utiliser un processus avec des condi-
signal BpgC : std_logic := '0'; tions if-else.
begin
ApgB <= '1' when A > B else '0';
ApgC <= '1' when A > C else '0';
BpgC <= '1' when B > C else '0';
with ApgB & ApgC & BpgC select
lamediane <=
B when "000",
C when "001",
A when "011",
A when "100",
C when "110",
B when "111",
(others => 'X') when others;
end arch;
Q2 Solution:
architecture arch of compteurUD is

begin
process(CLK, reset)
variable compte_int : signed(W - 1 downto 0);
begin
if reset = '1' then
compte_int := (others => '0');
else
if falling_edge(CLK) then
if go = '1' then
if UD = '1' then
compte_int := compte_int + 1;
else
compte_int := compte_int - 1;
end if;
end if;
end if;
end if;
compte <= compte_int;
end process;
end arch;
Q3 Solution:
DonneesIn(3)
DonneesIn(3)
DonneesIn(3) donneeOut
DonneesIn(3)
Requetes(3) 3
A1
Requetes(2) 2
A0
Requetes(1) 1
Encodeur à priorité
Requetes(0) 0 V donneeValide
Q4 Solution:
secondes (0 à 255)
/ >= 240? 4
encodeur à priorité
>= 180? 3 minutes

(0 à 4, sur 3 bits)
>= 120? 2 /
3
>= 60? 1
>= 0? 0
240 4
180 3
120 2 /
8
60 1
0 0 secondes
(0 à 59, sur 6 bits)
/
6
Q5 Solution :
À t = 0 + 2 Δ, évaluation des signaux S, T, U et G (provoquées par les changements sur A, B, C)
À t = 0 + 3 Δ, évaluation de F et G (provoquées par les changements sur S, T, U)
À t = 10 ns + 0 Δ, assignation de 1 à C
À t = 10 ns + 1 Δ, évaluation de U (provoquée par le changement sur C), ** mais pas d’évaluation de F
parce que C n’est pas dans la liste de sensitivité du processus **
À t = 10 ns + 2 Δ, évaluation de G (provoquée par le changement sur U)
b.
Q6 Solution :
a. Le chemin critique va des bascules des blocs d’entrée/sortie A-F aux bascules des blocs d’entrée/sortie
P-Q. Le délai total est donné par :
délai bascule + 3 × délai LUT + 4 × délai interconnexions + tsu = 0.75 + 3 × 2.25 + 4 × 0.2 + 0.25 = 8.55
ns. La fréquence maximale est donc 117 MHz.
b. La latence est de 8.55 ns.
c. Dans les tranches de la colonne 1, on insère les bascules dans le chemin du circuit. Le chemin critique
est donc coupé en deux et le délai est donné par :
ns. La fréquence maximale est donc 169 MHz – OK.
d. La latence est de deux cycles d’horloge, soit 11.8 ns.
e. Tentative #1 : On insère les bascules dans les tranches des colonnes 0, 1 et 2. Le chemin critique du
circuit va maintenant d’une colonne à une autre, et son délai est de :
ns. La fréquence maximale est donc 289 MHz, ce qui est insuffisant.
Puisqu’on ne peut pas pipeliner d’avantage, il faut donc dupliquer le circuit afin de doubler le nombre de
résultats calculés par seconde. Il y a suffisamment de tranches disponibles pour faire cela. En principe, on
pourrait ainsi atteindre un débit de 2 × 289 Mrésultats/s, soit 578 MRésultats/s. Cependant, il faudrait
aussi doubler le débit des entrées A à F, et aiguiller une entrée sur deux vers le circuit actuel, et l’autre
entrée sur deux vers le nouveau circuit.
f. La fréquence maximale d’horloge de ce FPGA est atteinte quand le chemin critique se résume à : bas-
cule, interconnexion, LUT, bascule, avec un délai de 0.75 + 2.25 + 0.2 + 0.25, correspondant à 289 MHz.
Nom : ________________________________________ Matricule : __________________________
Examen intra - vendredi 21 octobre 2011
Durée: 2h; Pondération: 20%
Ordinateurs interdits. Calculatrice: Programmable permise.
Répondre sur le questionnaire et le remettre. Vous pouvez utiliser le verso du questionnaire si nécessaire.
Ne détachez pas de pages du questionnaire.
Considérez le problème de la conception d’un cadenas numérique à cinq numéros entre 0 et 9, dont la
combinaison est 1-2-3-4-5. Le cadenas est doté d’un signal de réinitialisation reset, d’un bouton entrer
qui fait office d’horloge, et d’un port numero de quatre bits permettant de spécifier le numéro. Une sortie
ouvrir indique si le cadenas doit être déverrouillé ou non.
Pour débarrer le cadenas, un utilisateur devrait placer le nombre 1 sur le port numero, appuyer sur entrer,
placer le nombre 2 sur le port numero, appuyer sur entree, et ainsi de suite jusqu’à placer le nombre 5 sur
le port numero et appuyer sur entrer. Le signal ouvrir passerait alors de 0 à 1, et resterait à 1 tant que
l’utilisateur n’appuierait pas sur entrer à nouveau.
a. Donnez un diagramme d’états pour le cadenas. Vous devez utiliser une machine de Moore.
Solution :
1
reset 1 2
aucun autres
n1ok 1 n2ok
Ouvrir <= ‘0’ Ouvrir <= ‘0’ Ouvrir <= ‘0’
autres
3
1
1
autres
autres
debarre n4ok n3ok

Ouvrir <= ‘1’ Ouvrir <= ‘0’ Ouvrir <= ‘0’
5
4
b. Donnez une architecture synthétisable pour l’entité VHDL suivante correspondant à la spécification.
Des points seront accordés pour une architecture qui permet de changer facilement la combinaison.
library IEEE;
library IEEE;
entity cadenas is
port (
reset, entrer : in STD_LOGIC;
numero : in unsigned(3 downto 0);
ouvrir : out STD_LOGIC
);
end cadenas;
architecture arch of cadenas is

type combinaison is array (natural range <>) of natural range 0 to 15;
constant lacombine: combinaison := (1, 2, 3, 4, 5);
type type_etat is (aucun, n1ok, n2ok, n3ok, n4ok, debarre);
signal etat : type_etat := aucun;
begin
ouvrir <= '1' when etat = debarre else '0';
process(entrer, reset) is
begin
etat <= aucun;
elsif (rising_edge(entrer)) then
case etat is
when aucun =>
if numero = lacombine(0) then etat <= n1ok;
else etat <= aucun;
end if;
when n1ok =>
elsif numero = lacombine(0) then etat <= n1ok; -- pas dans la spéc.
else etat <= aucun;
end if;
when n2ok =>
else etat <= aucun;
end if;
when n3ok =>
else etat <= aucun;
end if;
when n4ok =>
if numero = lacombine(4) then etat <= debarre;
else etat <= aucun;
end if;
when debarre =>
etat <= aucun;
when others =>
etat <= aucun;
end case;
end if;
end process;
end arch;
a. Illustrez, avec un diagramme, le flot de conception que vous avez suivi dans les laboratoires du cours
INF3500 à ce jour, de la description du design à la vérification du fonctionnement de la puce.
Solution :
vérification de la puce
annotation
vérification par simulation
des délais
code HDL
génération du
schéma synthèse implémentation fichier de puce
génération configuration
de code
diagramme HDL
d’états
contraintes
(temps et
espace)
Extraction statique des métriques d’implémentation

(ressources, délai, puissance)
b. Dans le flot de conception, énumérez les différentes entrées possibles à l’étape de vérification par simu-
lation et expliquez leurs différences.
Solution :
1. Après la création/génération de code HDL. Vérification fonctionnelle seulement.
2. Après la synthèse. Vérification fonctionnelle des blocs synthétisés. Permet de vérifier que la synthèse a
bien fonctionné et que le produit de la synthèse est conforme aux intentions du concepteur.
3. Après l’implémentation. Vérification fonctionnelle avec annotation des délais estimés suite au place-
ment et au routage des blocs synthétisés. Les chronogrammes permettent de voir comment la propagation
des délais se fait dans le circuit. Cette vérification permet aussi de vérifier que l’implémentation a bien
fonctionné, et que son produit est conforme aux intentions du concepteur.
c. Selon votre expérience dans les laboratoires d’INF3500, énumérez trois métriques d’implémentation en
termes de ressources matérielles utilisées.
Réponse :
#LUTs, #bascules, #tranches (slices), #multiplieurs, #blocs d’entrée/sortie, #mémoire BRAM
Le réseau de Feistel est utilisé dans les algorithmes de chiffrement par bloc. Plusieurs algorithmes utili-
sent le réseau de Feistel, dont DES, Blowfish et RC5. Le diagramme suivant illustre un réseau de Feistel
simple à quatre étages. Les algorithmes cryptographiques basés sur un réseau de Feistel diffèrent princi-
palement dans le nombre d’étages et dans la nature de la fonction F.
K1 K2 K3 K4
A Y
F F F F
B oux oux oux oux Z
Le message à chiffrer est décomposé en un flux de nombres appliqués aux entrées A et B du réseau à
chaque coup d’horloge. Les quatre clés secrètes K1, K2, K3 et K4 restent normalement constantes pour le
chiffrement du message. Les sorties Y et Z sont un flux de nombres (une sortie par coup d’horloge) repré-
sentant le message chiffré.
On constate qu’à chaque étage le signal du haut est combiné à la clé par la fonction F. On effectue ensuite
un ou-exclusif bit à bit avec le signal du bas. À la fin de l’étage, les signaux du haut et du bas sont inter-
changés pour le prochain étage.
Ki
Supposez ici que tous fils du diagramme représentent un signal de
Fonction F
16 bits. Supposez que la fonction F consiste à appliquer une rota-
tion de l’entrée de 1 bit vers la droite puis à effectuer l’opération
Ror 1 oux
ou-exclusif bit à bit avec la clé Ki exprimée sur 16 bits.
Considérez la déclaration d’entité suivante pour le diagramme du réseau de Feistel. Donnez une architec-
ture en VHDL synthétisable correspondant à cette entité et au diagramme.
library IEEE;
entity feistel4 is
generic (
W : positive := 16
);
port (
A, B : in unsigned(W - 1 downto 0);
Y, Z : out unsigned(W - 1 downto 0);
K1, K2, K3, K4: unsigned(W – 1 downto 0)
);
end feistel4;
(répondre à la page suivante)
Réponse à la question 3 :
arch monarch of feistel4 is
signal A0, A1, A2, A3, A4, B0, B1, B2, B3, B4 : unsigned(W - 1 downto 0);
begin
-- registres à l'entrée pour A et B et à la sortie pour Y et Z

begin
if reset = '1' then
Y <= (others => '0');
Z <= (others => '0');
A0 <= (others => '0');
B0 <= (others => '0');
A0 <= A;
B0 <= B;
Y <= A4;
Z <= B4;
end if;
end process;
-- description du réseau comme tel

-- on pourrait aussi paramétrer A et B, puis utiliser une description
-- avec une boucle (dans un process) ou bien avec énoncé generate
B1 <= A0;
A1 <= (A0 ror 1) xor K1 xor B0;
B2 <= A1;
B3 <= A2;
B4 <= A3;
end monarch;
Considérez le problème de la conception du système numérique contrôlant un téléviseur à haute défini-
tion. Énumérez les entrées et les sorties. Proposez une décomposition de ce système en modules et faites
un partitionnement initial logiciel-matériel. Pour chaque module, justifiez brièvement votre choix entre
une implémentation en logiciel (L) et une implémentation en matériel (M).
Solution :
Balayage de l’écran
Traitement d’image (M)
Source(s) de (M)
{En M à cause du très grand débit
signaux {M à cause du Écran
d’information – besoin de performance
vidéo/audio grand débit
maximale}
d’information}
Traitement du son (M/L)

Haut-
{M ou L: algorithmes complexes mais
parleurs
débit d’information réduit}
Panneau de
contrôle
Interface (M)
{M faible
Télécomman
complexité,
de
pas besoin
d’un uP} Contrôle (L)
{L parce que fonctions de contrôle complexes, Panneau
besoin de flexibilité lors du développement, d’affichage
Interface (M) interfaces à l’utilisateur à débit très faible}
{M faible
Routeur
complexité,
WiFi
pas besoin
Note: On pourrait rajouter des blocs d’interface analogique
d’un uP}
(filtrage, amplification, démodulation, conversion A/D et D/
Dispositif A, etc.) mais ces sujets sortent de la matière de INF3500.
HDMI
On pourrait aussi rajouter le contrôle de sources multiples
de signaux vidéo/audio.
Considérez le code VHDL suivant. Montrez, sur le library ieee;
modèle de FPGA fourni aux pages suivantes, un entity monModule6 is
résultat possible de la synthèse et de port (
l’implémentation de ce code. reset, clk: in std_logic;
A, B, C, D, E, F : in std_logic;
a. Indiquez directement sur le dessin où chaque Y, Z : out std_logic
signal se situe ainsi que les interconnections entre );
les blocs. end monModule6;
architecture arch of monModule6 is
b. Indiquez dans les tables de vérité fournies le signal T1, T2 : std_logic;
contenu de chacune des tables de conversion que begin
vous utilisez. T1 <= (A and B) or C;
Z <= (T1 or T2) and D;
begin
T2 <= '0';
Y <= '0';
T2 <= (A and B and C) xor F;
Y <= T2 and A and E and F;
end if;
end process;
end arch;
Réponse à la Question 5 a.
G4
A YQ
B
G3
Table de
D Q
T2
conversion
G2 G reset
C G1
16 X 1 S0
F Y
H1 S1
F4
T2 F3 D Q
XQ
Y
Table de
A F2
conversion
F reset
16 X 1 S2
E F1
F X
S3
CLK
reset
G4
A YQ
G3 D Q
B G2
Table de
conversion
G reset
C G1
16 X 1 S0
H
T1
H1 S1
F4
T1 F3 D Q
XQ
Table de
T2 F2
conversion
F reset
16 X 1 S2
D F1
X
Z
S3
CLK
reset
Réponse à la question 5 b.
G4 G3 G2 G1 G F4 F3 F2 F1
F(Y )
(A ) (B ) (C ) (F ) (T2 ) (T2 ) (A ) (E ) (F )
0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 1 0
0 0 1 0 0 0 0 1 0 0
0 0 1 1 1 0 0 1 1 0
0 1 0 0 0 0 1 0 0 0
0 1 0 1 1 0 1 0 1 0
0 1 1 0 0 0 1 1 0 0
0 1 1 1 1 0 1 1 1 0
1 0 0 0 0 1 0 0 0 0
1 0 0 1 1 1 0 0 1 0
1 0 1 0 0 1 0 1 0 0
1 0 1 1 1 1 0 1 1 0
1 1 0 0 0 1 1 0 0 0
1 1 0 1 1 1 1 0 1 0
1 1 1 0 1 1 1 1 0 0
1 1 1 1 0 1 1 1 1 1
G4 G3 G2 G F4 F3 F2
G1 ( ) F1 ( ) F (Z )
(A ) (B ) (C ) (T1 ) (T1 ) (T2 ) (D )
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 1 0
0 0 1 0 1 0 0 1 0 0
0 0 1 1 1 0 0 1 1 0
0 1 0 0 0 0 1 0 0 0
0 1 0 1 0 0 1 0 1 0
0 1 1 0 1 0 1 1 0 1
0 1 1 1 1 0 1 1 1 1
1 0 0 0 0 1 0 0 0 0
1 0 0 1 0 1 0 0 1 0
1 0 1 0 1 1 0 1 0 1
1 0 1 1 1 1 0 1 1 1
1 1 0 0 1 1 1 0 0 0
1 1 0 1 1 1 1 0 1 0
1 1 1 0 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1
INF3500 – final – été 2011
a- Qu’est-ce que le temps de propagation td? À quoi correspond-il dans une bascule D?
temps nécessaire pour que la sortie de la composan-te se stabilise suite à un changement à l‟une de
ses entrées. Pour les loquets et les bascules, on mesure en général le délai de propagation à partir de
la transition de l‟horloge
b- Qu’est-ce que le temps de préparation tsu?
temps minimal pendant lequel le signal d‟entrée de la bascule ou du loquet ne doit pas changer
avant la transition active de l‟horloge
c- Qu’est-ce que le temps de maintien th?
temps minimal pendant lequel le signal d‟entrée de la bascule ou du loquet ne doit pas changer
après la transition active de l‟horloge.
d- Qu’est-ce que la métastabilité? Quand peut-elle se produire?
Si le temps de préparation ou le temps de maintien ne sont pas respectés, alors la bascule ou le loquet
risquent d‟entrer dans un état métastable, c'est-à-dire que leur sortie aura un niveau imprévisible
entre 0 et 1.
e- Proposez une méthode permettant de sortir de la métastabilité (avec schéma à l’appui).
Une solution habituelle consiste à utiliser deux bascules connectées en cascade. Dans ce circuit, la
première bascule est reliée à la source asynchrone. Son signal de sortie, Smeta, peut être métastable..
Si la première bascule entre dans un état métastable, elle finira en pratique par se stabiliser sur un 0
ou un 1. La deuxième bascule permet d‟accorder le plus long temps possible à la première pour se
stabiliser, soit une période d‟horloge.
Sasync Smeta Ssync
Source D Q D Q
asynchrone
Système synchrone
clk
Dans ses FPGAs, Xilinx met à la disposition des concepteurs des blocs permettant d’effecteur de puis-
sants calculs sans avoir besoin d’utiliser les look-up tables (LUTs) du FPGA. Ces blocs sont des DSP48.
Les DSP48 sont des blocs qui supportent plusieurs fonctions : multiplication, multiplication-
accumulation, addition…
Une version simplifiée d’un DSP48 est représentée dans la figure ci-dessous :
INF3500 – Examen final –24 Août 2011
“00000”&A&B
A 25
0 x
X_sel
M
X
P
B 18 0 y +/- 48
y_sel
opmode
0
C 48
0 z
z_sel
Les paramètres de configuration sont

A_reg= 0,1 ou 2 : nombre de registres en série sur l’entrée A (deux sont montrés sur le diagramme)
B_reg= 0,1 ou 2 : nombre de registres en série sur l’entrée B (deux sont montrés sur le diagramme)
C_reg= 0,1 : nombre de registres en série sur l’entrée C (un est montré sur le diagramme)
M_reg= 0,1 : nombre de registres en série sur la sortie du multiplicateur (un est montré sur le dia-
gramme)
P_reg= 0,1 : nombre de registres en série sur la sortie P (un est montré sur le diagramme)
x_sel x
0 A&B
1 0
2 M
y_sel y
0 M
1 0
2 C
z_sel z
0 0
1 0
2 C
Opmode operation
0 addition
1 soustraction
On aimerait effectuer la multiplication de deux nombres complexes : (R +iS)* (T +iU). Sous forme de
schéma bloc, proposez trois architectures basées sur les DSP48 :
- Une qui minimise la latence
- Une qui maximise la fréquence maximale
- Une qui minimise le nombre de ressources utilisées
Les trois architectures doivent maximiser le débit. Pour chaque DSP48 utilisé, précisez les paramètres de
configuration choisis. Ne faites pas attention à la largeur des données.
Minimisation de la latence
DSP1 DSP4
DSP1 A_reg=0 A_reg=0
a B_reg=0 B_reg=0
R C_reg=0 C_reg=0
X M_reg=0 M_reg=0
P_reg =0
T b
P_reg=0
X_sel=1 X_sel=1
DSP3 Y_sel=0 Y_sel=0
Z_sel=0 Z_sel=0
b
Opmode=0 Opmode=0
- Partie réelle
c
DSP2 DSP2 DSP5
A_reg=0 A_reg=0
a B_reg=0
S B_reg=0
C_reg=0
C_reg=0
X M_reg=0 M_reg=0
P_reg =0
U b
P_reg=0
X_sel=1
X_sel=1
Y_sel=0 Y_sel=0
Z_sel=0 Z_sel=0
Opmode=0 Opmode=0
DSP4 DSP6
R a DSP3 A_reg=0
A_reg=0
B_reg=0
X B_reg=0
C_reg=0
C_reg=0
U b M_reg=0 M_reg=0
DSP6 P_reg =0 P_reg=0
X_sel=0
X_sel=0
b Y_sel=1 Y_sel=1
Z_sel=2
+ Partie imaginaire Z_sel=2
Opmode=1 Opmode=0
c
DSP5
a
S
X
T b
Maximisation de la fréquence maximale
DSP1 DSP4
DSP1 A_reg=2 A_reg=2
a B_reg=2 B_reg=2
R C_reg=0 C_reg=0
X M_reg=1 M_reg=1
P_reg =1
T b
P_reg=1
X_sel=1 X_sel=1
DSP3 Y_sel=0 Y_sel=0
Z_sel=0 Z_sel=0
b
Opmode=0 Opmode=0
- Partie réelle
c
DSP2 DSP2 DSP5
A_reg=2 A_reg=2
a B_reg=2
S B_reg=2
C_reg=0
C_reg=0
X M_reg=1 M_reg=1
P_reg =1
U b
P_reg=1
X_sel=1
X_sel=1
Y_sel=0 Y_sel=0
Z_sel=0 Z_sel=0
Opmode=0 Opmode=0
DSP4 DSP6
R a DSP3 A_reg=0
A_reg=0
B_reg=1
X B_reg=1
C_reg=1
C_reg=1
U b M_reg=0 M_reg=0
DSP6 P_reg =1 P_reg=1
X_sel=0
X_sel=0
b Y_sel=1 Y_sel=1
Z_sel=2
+ Partie imaginaire Z_sel=2
Opmode=1 Opmode=0
c
DSP5
a
S
X
T b
Minimisation de l'utilisation des ressources

DSP1
a
R
X
T b
DSP1 DSP3
DSP2 - Partie réelle A_reg=0 A_reg=0
B_reg=0
B_reg=0
a C_reg=0
S c C_reg=0
M_reg=0
M_reg=0
X P_reg=0 P_reg =0
U b
X_sel=1 X_sel=1
Y_sel=0
Y_sel=0
Z_sel=2 Z_sel=2
Opmode=1 Opmode=0
DSP2 DSP4
A_reg=0 A_reg=0
B_reg=0 B_reg=0
C_reg=0 C_reg=0
M_reg=0 M_reg=0
P_reg=0 P_reg =0
DSP3 X_sel=1 X_sel=1
Y_sel=0 Y_sel=0
a Z_sel=0
R Z_sel=0
Opmode=0
Opmode=0
X
T b
DSP4 + Partie imaginaire

a
S c
X
U b
A
F
S
C
D
G
CLK dephasage
a- Déterminez sa fréquence maximale en considérant un temps de préparation de 1 ns, un temps de

maintien de 0.5 ns, un temps de propagation dans les bascules de 2 ns et un temps de propagation
dans les portes ET, OU, XOR et INV de 2 ns, 2 ns, 3 ns, 1 ns respectivement. Le temps de propa-
gation dans les interconnexions est considéré nul.
Pour déterminer la période minimale de chaque chemin: T = tcomb+tsu+td
A vers F: T=2+2+2+1 = 7ns
B vers F: T=1+1+2+2+1= 7ns
B vers G: T=3+3+1+2+1= 10 ns
C vers G: T=2+2+3+1+2+1= 11 ns
D vers G: T=2+2+3+1+2+1= 11 ns
E vers G: T=2+2+3+1+2+1=11ns
F vers A: T=2+2+1=5ns
G vers A: T=2+2+1=5ns
Le chemin le plus long fait 11 ns. La fréquence maximale du circuit est donc 1/11ns= 90.9Mhz
b- Déterminez la marge libre de préparation de chaque chemin.

On applique la formule Tmin-T, T etant la période minimale de chaque chemin, et Tmin la période
minimale du circuit
A vers F: 11-7 = 4ns
B vers F: 11-7= 4ns
B vers G: 11-10= 1 ns
C vers G: 11-11= 0 ns
D vers G: 11-11= 0 ns
E vers G: 11-11=0ns
F vers A: 11-5=6ns
G vers A: 11-5=6ns
c- Quelles sont les bornes minimales et maximales du déphasage d’horloge acceptables tout en ga-
rantissant cette fréquence maximale?
Pour chaque chemin, on va determiner les bornes du déphasage d'horloge
T>= tcomb+tsu+td-tcs d'où la borne tcs >= tcomb+tsu+td-T
tcomb +td-tcs>th d'où la borne tcs < tcomb+td-th
A vers F: -4ns<=tcs<5.5ns
B vers F: -4ns<=tcs<5.5ns
B vers G: -1 ns <= tcs <8.5ns
C vers G: 0ns<=tcs<9.5ns
D vers G: 0ns<=tcs<9.5ns
E vers G: 0ns<=tcs<9.5ns
F vers A: -6ns<=tcs<3.5ns
G vers A: -6ns<=tcs<3.5ns
Pour que le circuit continue de bien fonctionner, les bornes de déphasage acceptables sont:
0ns<=tcs<3.5ns
d- En considérant un déphasage d’horloge nul, ajoutez un étage de pipeline permettant d’augmenter

la fréquence maximale. Déterminez la nouvelle fréquence maximale.
A X
F
Y
B
S
C
D
G
CLK dephasage
Z vers G T= 3+1+2+1=7ns. Fréquence max= 142.8 Mhz
Le code VHDL suivant est une portion d'un contrôleur de lecture d'une mémoire. Lorsque le contrôleur
reçoit la commande de début de lecture read_en, il envoie les adresses de lecture au bloc mémoire.
Deux modes de fonctionnement existent: le mode calibration et le mode hors-calibration.
- Lorsque le contrôleur est en mode hors-calibration (signal calibration_mode à 0), 8192 échantil-
lons sont lus de la mémoire. Chaque échantillon est lu à chaque front montant du signal pulse_read.
- Lorsque le controleur est en mode calibration (signal calibration_mode à 1), 1024 échantillons
sont lus de la mémoire. Chaque échantillon est lu au huitième front montant du signal pulse_read.
library ieee;
use ieee.std_logic_unsigned.all;
entity ctl_fifo_example is
port (
clk_sys : in std_logic; --horloge du systeme
rst_n : in std_logic; -- reset du systeme, actif bas
read_en : in std_logic; -- indique au controleur qu'il peut demarrer la
-- lecture
pulse_read : in std_logic;
calibration_mode : in std_logic; -- mode: calibration hors_calibration?
rd_addr : buffer std_logic_vector(12 downto 0)
);
end ctl_fifo_example ;
architecture ctl_fifo_example_a of ctl_fifo_example is
---------------------------------------------------------
-- types definition
---------------------------------------------------------
type t_state is (IDLE, SEND_DATA);
---------------------------------------------------------
-- signals definition
---------------------------------------------------------
signal state : t_state;
signal max_rd_addr : std_logic_vector(12 downto 0);
signal read_en_1q : std_logic;
signal read_en_2q : std_logic;
signal read_en_r : std_logic;
signal read_en_f : std_logic;
signal calib_mode : std_logic;
signal count_pulse : std_logic_vector(3 downto 0);
signal pulse_read_1q : std_logic;
signal pulse_read_r : std_logic;
begin
delay_p:process(clk_sys, rst_n)
begin
if rst_n = '0' then
read_en_1q <= '0';
read_en_2q <= '0';
pulse_read_1q <= '0';
elsif rising_edge(clk_sys) then
read_en_1q <= read_en;
read_en_2q <= read_en_1q;

pulse_read_1q <= pulse_read;
end if;
end process;
read_en_r <= read_en_1q and not read_en_2q; --détection du front montant de read_en
read_en_f <= read_en_2q and not read_en_1q; --détection du front descendant de
--read_en
pulse_read_r <= pulse_read and not pulse_read_1q; --détection du front montant de
--pulse_read
state_machine_p:process(clk_sys, rst_n)
begin
if rst_n = '0' then
state <= IDLE;
rd_addr <= (others => '0');
max_rd_addr <= (others => '0');
count_pulse <= (others => '0');
calib_mode <= '0';
case state is
when IDLE =>
if read_en_r = '1' then
if calibration_mode = '1' then
max_rd_addr <= '0'& X"3FF"; --1024 échantillons à lire en mode
--calibration
calib_mode <= '1';
else
max_rd_addr <= (others => '1'); --8192 échantillons à lire en
--mode hors-calibration
calib_mode <= '0';
end if;
state <= SEND_DATA;
count_pulse <= "0000";
end if;
when SEND_DATA =>
if pulse_read_r = '1' then
count_pulse <= count_pulse + 1;
if count_pulse = "0111" then
count_pulse <= (others => '0');
end if;
if calib_mode = '0' then

rd_addr <= rd_addr + 1;
elsif count_pulse = "0111" then
rd_addr <= rd_addr + 1;
end if;
end if;
if (rd_addr = max_rd_addr and count_pulse = "0111")
or (read_en_f = '1') then
state <= IDLE;
end if;
when others => NULL;
end case;
end if;
end process;
end ctl_fifo_example_a;
Donnez un banc d’essai pour ce contrôleur. Le banc d'essai devra garantir une couverture de branchement
de 100% tout en minimisant le nombre de vecteurs de tests appliqués.
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
ENTITY ctl_fifo_tb IS
END ctl_fifo_tb;
ARCHITECTURE behavior OF ctl_fifo_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT ctl_fifo_example
PORT(
clk_sys : IN std_logic;
rst_n : IN std_logic;
read_en : IN std_logic;
pulse_read : IN std_logic;
calibration_mode : IN std_logic;
rd_addr : buffer std_logic_vector(12 downto 0)
);
END COMPONENT;
--Inputs
signal clk_sys : std_logic := '0';
signal rst_n : std_logic := '0';
signal read_en : std_logic := '0';
signal pulse_read : std_logic := '0';
signal calibration_mode : std_logic := '0';
--Outputs
signal rd_addr : std_logic_vector(12 downto 0);
-- Clock period definitions

constant clk_sys_period : time := 10 ns;
BEGIN
-- Instantiate the Unit Under Test (UUT)

uut: ctl_fifo_example PORT MAP (
clk_sys => clk_sys,
rst_n => rst_n,
read_en => read_en,
pulse_read => pulse_read,
calibration_mode => calibration_mode,
rd_addr => rd_addr
);
-- Clock process definitions

clk_sys_process :process
begin
clk_sys <= '0';
wait for clk_sys_period/2;
clk_sys <= '1';
wait for clk_sys_period/2;
end process;
process(clk_sys,rst_n)
begin
if rst_n = '0' then
pulse_read <= '0';
pulse_read <= not pulse_read;
end if;
end process;
-- Stimulus process
stim_proc: process
begin
-- hold reset state for 100 ns.
wait for 100 ns;
rst_n <= '1';
wait for clk_sys_period*10;
read_en <= not read_en; -- premier front montant de read enable
read_en <= not read_en; -- premier front descendant de read enable
calibration_mode <= '1'; -- second front montant de read enable
read_en <= not read_en; -- second front montant de read enable
read_en <= not read_en; -- second front descendant de read enable
wait;
end process;
END;.…
….
ré par le chronomètre, en secondes. Alors la distance D est donnée par D = T × c / 2, où c = 3 × 108 m/s.
a- Donnez un diagramme représentant le chemin des données du processeur.
Solution
+ 1
D Q x D Q D
compteur
constante
compte
initialiser
b- Donnez le diagramme d’états de l’unité de contrôle du processeur.
Solution
reset bouton = ‘1’ detecteur = ‘1’
ZERO COMPTER AFFICHER

ATTENTE
Compteur <= 0 Compteur++ D<= compteur X
D<= 0;
D<= 0; D<= 0; constante;
Impulsion <= ‘0’
Impulsion <= ‘1’ Impulsion <= ‘0’ Impulsion <= ‘0’
Il faudrait ajouter une valeur maximale au

compteur. Quand cette valeur sera atteinte,
indiquant qu’un écho lumineurx n’a pas été recu, le bouton = ‘1’
système afficherait un message d’erreur.
Examen intra
Durée: 2h.
Pondération: 20%.
• Répondre sur le questionnaire et le remettre.
• Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute
Considérez le code vhdl suivant.

signal a: std_logic;
signal b : std_logic;
signal c: std_logic;
signal s: std_logic:='0';
process(a,b,c)
variable temp: std_logic;
begin
temp:= b or c;
temp:= temp and c;
s <= temp and not a;
s <= s or not a;
end process
a. Donnez la différence entre un signal et une variable.(1 point)

b. En vous servant du code donné, complétez le diagramme temporel suivant (2 points)
Solution :
a. Voir notes de cours, section 2.3.3
b.
Considérez le code vhdl suivant.

signal a: std_logic;
signal b : std_logic;
signal c: std_logic;
signal s: std_logic;
process(a,b,s)
variable temp: std_logic;
begin
temp:= b and c;
s <= temp and not a;
end process
a. Expliquez brièvement comment le simulateur évalue un process en fonction de la liste de sensibilité. ( 1

point)
b. En vous servant du code donné, complétez le diagramme temporel suivant : 2 points
Solution :
a. Voir notes de cours, section 7.3.1
b.
vement,
encodées sur 4 bits) du nombre. La sortie erreur est activée si le nombre est égal ou supérieur à
1000.
library ieee;
port(

);
end unsigned2dec;
begin

process(nombre)
begin
c := 0;
c := centaines;
exit;
end if;
end loop;
n := n - c * 100;
d := 0;
d := dizaines;
exit;
end if;
end loop;
u := n - d * 10;
end process;
end arch;
Pour l’entité unsigned2dec décrite ci-dessus, composez un banc d’essai qui effectue un test exhaustif
et qui vérifie que la sortie est valide en tout temps. Une sortie valide indique correctement les unités,
les dizaines et les centaines pour des nombres entre 0 et 999, inclusivement. Pour les autres nombres,
le signal d’erreur doit être actif. Dans le cas d’une erreur, votre banc d’essai doit simplement afficher le
message « erreur » à la console et se terminer.

library ieee;
entity unsigned2dec_TB is
end unsigned2dec_TB;

--- votre code ici
begin
--- votre code ici

signal nombre : unsigned(9 downto 0);
signal centainesBCD, dizainesBCD, unitesBCD : unsigned(3 downto 0);
signal erreur : std_logic;
begin
UUT : entity unsigned2dec(arch)
port map (nombre, centainesBCD, dizainesBCD, unitesBCD, erreur);
process
variable n : natural;
begin
nombre <= to_unsigned(k, nombre'length);
wait for 10 ns;
n := to_integer(centainesBCD) * 100
+ to_integer(dizainesBCD) * 10
+ to_integer(unitesBCD);
if (k <= 999) then
assert to_integer(centainesBCD) <= 9 report "erreur!" severity failure;
assert to_integer(dizainesBCD) <= 9 report "erreur!" severity failure;
assert to_integer(unitesBCD) <= 9 report "erreur!" severity failure;
assert n = k report "erreur!" severity failure;
else
end if;
end loop;
end process;
On vous demande de concevoir le chemin de données et la machine à état d'un ascenseur servant dans un
immeuble à 8 étages (allant de l'étage 0.à l'étage 7).
L’ascenseur peut être dans quatre états possibles :
- Il peut être en état d’attente d’une nouvelle commande. En état d’attente, il se rend à l’étage
d’appel lorsque l’utilisateur l’appelle ( signal « appel » mis à 1)
- Il peut être ouvert ( pour accepter un nouveau passager ou en faire sortir un). Quand il est ouvert,
l’utilisateur peut rentrer l’étage désiré et le valider avec le signal « go »
- Si après 3 secondes d’ouverture, l’utilisateur ne rentre pas l’étage désiré, l’ascenseur retourne en
mode d’attente
- Il peut être en train de monter pour se rendre à l’étage désiré ou l’étage d’appel
- Il peut être en train de descendre pour se rendre à l’étage désiré ou l’étage d’appel
Les entrées/sorties de l’entité sont les suivantes :

Appel : actif quand un passager veut utiliser l’ascenseur
Étage d’appel : étage où se situe le passager qui veut utiliser l’ascenseur
Étage destination : une fois entré dans l’ascenseur, le passager sélectionne l’étage où il veut se rendre
Go : actif quand l’utilisateur a rentré l’étage de destination
Ouvert : actif quand l’ascenseur est ouvert
On suppose que ca prend une seconde pour se rendre d’un étage à l’autre. Une horloge de 1 Hz est utilisée
pour ce circuit
a. En fonction du degré d'abstraction désiré et du type d'opération à effectuer, discutez du type de signal
que vous pouvez utiliser pour concevoir ce système. (1 point)
b. Dessiner la machine à état du système. (4 points)
c. Décrire la machine à état à l'aide du code VHDL. Les signaux de contrôle peuvent être implicites. (5
points)
Solution :
a. Le type std_logic_vector ( librairie .std_logic_1164) pourrait être utilisé s'il n'y a pas d'opération arith-
métique à effectuer. Dans notre cas, le compteur effectue une opération arithmétique.
Le type unsigned (librairie numeric_std ) permet d'effectuer des opération arithmétiques, et dérive direc-
tement du type std_logic
Le type integer est plus abstrait mais il ne faut pas oublier de spécifier la largeur des bits.
Le type unsigned est le bon compromis
b.
Appel = ‘1’ Désiré > actuel
decision
Compte <= actuel - désiré

Compte --
attente
Désiré = actuel
monter
Désiré < actuel

Compte <= désiré-actuel
Compte --
Go = 1
Go = 0
Compte = 0
ouvert
Compte_ouvert <=compte_ouvert --
descendre Compte = 0
Compte <= actuel - désiré
Compte --
Compte_ouvert = 0
c.
-- Code VHDL
library IEEE;
entity ascenseur is
port(
reset_n : in std_logic;
clk : in std_logic;
appel : in std_logic;
etage_appel : in std_logic_vector(2 dowmto 0);
go : in std_logic;
etage_destination : in std_logic_vector(2 downto 0);
ouvert : out std_logic;
etage_actuel : out std_logic_vector(2 downto 0)
);
end ascenseur;
architecture arch of ascenseur is

signal compte: unsigned(2 downto 0);
signal compte_ouvert: unsigned(1 downto 0);
signal reg_actuel : unsigned(2 downto 0);
signal reg_desire: unsigned(2 downto 0);
type t_etat is (attente, decision, ouverture, monter, descendre);
signal etat : t_etat;
begin
process(clk,reset_n)
begin
if reset_n = ‘0’ then
etat <= attente;
ouvert <= ‘0’;
compte <= (others => ‘0’);
compte_ouvert <= (others => ‘0’);
reg_actuel <= (others => ‘0’);
reg_desire <= (others => ‘0’);
case etat is
when attente =>
if appel = '1' then
reg_desire <= unsigned(etage_appel);
etat <= decision;
end if;
when decision =>
if reg_desire = reg_actuel then
etat <= ouverture;
ouvert <= '1';
compte_ouvert <= "10";
elsif reg_desire > reg_actuel then
etat <= descendre;
ouvert <= '0';
compte <= reg_actuel - reg_desire;
elsif reg_desire < reg_actuel then
etat <= monter;
ouvert <= '0';
compte <= reg_desire - reg_actuel;
end if;
when monter =>
compte <= compte - 1;
if compte = "000" then
etat <= ouverture;
ouvert <= '1';
else
reg_actuel <= reg_actuel + 1;
ouvert <= '0';
end if;
when descendre =>
if compte = "000" then
etat <= ouverture;
ouvert <= '1';
else
reg_actuel <= reg_actuel - 1;
ouvert <= '0';
end if;
when ouverture =>
ouvert <= '1';
if go = '0' then
compte_ouvert <= compte_ouvert - 1;
if compte_ouvert = "00" then
etat <= attente;
ouvert <= '0';
end if;
else
reg_desire <= unsigned(etage_destination);
etat <= decision;
ouvert <= '0';
end if;
when others => etat <= attente;
end case;
end if;
end process;
etage_actuel <= std_logic_vector(reg_actuel);
end arch;
Examen final
Avril 2011
Durée: 2h30.
Pondération: 40%.
 Ne pas remettre le questionnaire, sauf la dernière page qui doit être annotée et remise.
 Ne posez pas de questions. En cas de doute sur le sens d’une question, énoncez clairement toute sup-
Une porte universelle peut réaliser toutes les fonctions logiques possibles de ses entrées. La fonction dési-
rée est spécifiée par un port de contrôle spécial. Pour une porte universelle à deux entrées x et y, il y a 16
possibilités de fonctions logiques Fop, où 0 ≤ op ≤ 15, tel que montré dans la table de vérité combinée
suivante. On observe que les fonctions F0 et F15 sont des constantes, alors que les fonctions F3, F5, F10 et
F12 se réduisent à des fonctions à une seule variable.
x y Fo F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
1 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
Donnez une architecture pour l’entité suivante en VHDL synthétisable, afin de réaliser une porte univer-
selle à deux entrées.
library ieee;
entity porteUniverselle2 is
port (
x, y : in std_logic;
op : in unsigned(3 downto 0); -- opération à effectuer
F : out std_logic
);
end porteUniverselle2;
Solution :
-- solution ‘simple’ -- solution la plus simple
architecture arch of porteUniverselle2 is architecture arch2 of porteUniverselle2 is
begin begin
process (x, y, op) F <= op(to_integer(not(unsigned(x & y))));
begin end arch2;
case to_integer(op) is
when 0 => F <= '0';
when 1 => F <= x and y;
when 2 => F <= x and not(y);
when 3 => F <= x;
when 4 => F <= not(x) and y;
when 5 => F <= y;
when 6 => F <= x xor y;
when 7 => F <= x or y;
when 8 => F <= not(x or y);
when 9 => F <= not(x xor y);
when 10 => F <= not(y);
when 11 => F <= not(not(x) and y);
when 12 => F <= not(x);
when 13 => F <= not(x and not(y));
when 14 => F <= not(x and y);
when 15 => F <= '1';
end case;
end process;
end arch;
ré par le chronomètre, en secondes, alors la distance D est donnée par D = T × c / 2, où c = 3 × 108 m/s.
a. Donnez un diagramme représentant le chemin des données du processeur.
Solution :
a.
1
D Q D Q D
compteur
compte constante
CLK CLK
initialiser
b.
reset
bouton = ‘1’ détecteur = ‘1’
zéro compter afficher

attente
compteur <= 0; compteur++ D <= compteur X
D <= 0;
D <= 0; D <= 0; constante;
impulsion <= 0;
impulsion <= 1; impulsion <= 0; impulsion <= 0;
Il faudrait ajouter une valeur maximale au compteur. Quand

cette valeur serait atteinte, indiquant qu’un écho lumineux n’a bouton = ‘1’
pas été reçu, le système afficherait un message d’erreur.
vement, encodées sur 4 bits) du nombre. La sortie erreur est activée si le nombre est égal ou supérieur à
1000.
library ieee;
port(
);
end unsigned2dec;

begin
process(nombre)
begin

c := 0;
c := centaines;
exit;
end if;
end loop;
n := n - c * 100;

d := 0;
d := dizaines;
exit;
end if;
end loop;
u := n - d * 10;

end process;
end arch;
Solution :
nombre unitésBCD
>= 900? 9 >= 90? 9
>= 800? 8 >= 80? 8
100 10
>= 700? 7 >= 70? 7
c d
>= 600? 6 / >= 60? 6 /
4 4
encodeur à priorité encodeur à priorité
>= 500? 5 9:4 >= 50? 5 9:4
valeur par défaut de 0 valeur par défaut de 0
>= 400? 4 >= 40? 4
dizainesBCD
>= 300? 3 >= 30? 3
>= 200? 2 >= 20? 2
>= 100? 1 >= 10? 1
centainesBCD
>= 1000? erreur
Considérez le circuit suivant. Les délais des portes logiques combinatoires sont indiqués. Les bascules ont
un temps de propagation de 2 ns, un temps de préparation de 1 ns, et un temps de maintien de 0.5 ns.
Chaque fil du circuit a un délai de propagation de 0.1 ns.
D Q
A
3 ns D Q
CLK 3 ns
2 ns F
3 ns
CLK
D Q
1 ns
B
2 ns
CLK 2 ns
D Q
C 4 ns
CLK 4 ns
a. Supposez que toutes les bascules sont alimentées par le même signal d’horloge. Donnez le chemin cri-
tique en indiquant les composantes sur ce chemin, et donnez la fréquence maximale d’horloge.
b. On veut maximiser la fréquence d’horloge du circuit en insérant des registres de pipeline. Les registres
ajoutés ont les mêmes caractéristiques que les registres actuels du circuit, et chaque fil ajouté a un délai de
propagation de 0.1 ns. Il n’y a pas de déphasage d’horloge. En supposant que vous pouvez ajouter autant
de registres que vous le voulez, quelle est la fréquence maximale d’opération du circuit? Expliquez com-
plètement votre réponse.
c. Le circuit initial sans pipeline a été disposé de façon inappropriée sur une puce, et la bascule A reçoit
un signal d’horloge qui est 3 ns en retard sur les signaux d’horloge des autres bascules. Quelle est la fré-
quence maximale d’horloge? Expliquez complètement votre réponse.
Solution :
a. Bascule C, OUX, ETX, NOU, OU, Bascule F. Délai : 2 + 0.1 + 4 + 0.1 + 4 + 0.1 + 2 + 0.1 + 3 + 0.1 =
15.5 ns, + tsu(1 ns) = 16.5 ns. Fmax = 60.6 MHz.
b. On ajoute une bascule après chaque porte logique. Il en faut une aussi sur le fil entre la bascule C et
l’entrée et la porte ETX. Le chemin critique débute dans une bascule, passe à travers la porte OUX ou la
porte ETX, et va à une autre bascule. Le délai est 2 + 0.1 + 4 + 0.1 + tsu(1ns) = 7.2 ns, fmax = 138.8
MHz.
c. Le chemin critique devient alors bascule A, ET, OU, NON-ET, OU, bascule F. Délai : tcs(3 ns) + 2 +
0.1 + 3 + 0.1 + 3 + 0.1 + 2 + 0.1 + 3 + 0.1 + tsu(1 ns) = 17.5 ns. Fmax = 57.1 MHz.
Réponses brèves.
a. Considérez le code VHDL suivant. Quelle valeur prendra le port F lors de la simulation? Pourquoi?
library IEEE;
port (F : out std_logic);
end exempleSignaux;
begin
F <= '1';
F <= '0';
end arch1;
b. Considérez le code VHDL suivant. Quelle valeur prendra le port F lors de la simulation si A = ‘1’?
Pourquoi?
library IEEE;
port (A : in std_logic; F : out std_logic);
end exempleSignaux;
begin
process(A)
begin
F <= A;
F <= not(A);
end process;
end arch2;
c. En VHDL, les types STD_LOGIC_VECTOR, UNSIGNED et SIGNED sont très utilisés pour la simulation et la
synthèse de système numériques. Les trois types ont exactement la même définition :
type STD_LOGIC_VECTOR is array ( NATURAL range <>) of STD_LOGIC;
type UNSIGNED is array ( NATURAL range <>) of STD_LOGIC;
type SIGNED is array ( NATURAL range <>) of STD_LOGIC;
Expliquez la nécessité d’avoir ces trois types et ce qui rend l’utilisation de chacun distincte des autres.
d. Il y a quatre considérations fondamentales pour l’implémentation d’un système numérique, dont la

taille du système. Énumérez les trois autres.
e. Nommez et décrivez brièvement une des trois technologies de programmation les plus populaires pour
FPGA.
f. Pour le FPGA XC2VP30-FF896 utilisé dans les laboratoires, il y a deux façons d’implémenter de la
mémoire RAM : la mémoire RAM distribuée (Distributed RAM) et la mémoire RAM bloc (Block RAM).
Décrivez brièvement ces deux ressources et expliquez leurs différences.
Solutions :
a. Le port F prendra la valeur ‘X’ parce qu’il a deux sources de deux valeurs différentes.
b. Le port F prendra la valeur ‘0’ parce que dans le processus c’est la dernière assignation à F qui sera
gardée.
c. Les trois types ont des utilisations différentes. Le type STD_LOGIC_VECTOR est utilisé pour les va-
leurs logiques, les deux autres pour des valeurs numériques. L’utilisation de chaque type est distincte à
cause des fonctions, procédures et opérateurs qui sont définis et/ou surchargés pour chaque type.
d. Taux de traitement, puissance consommée et précision des calculs.
e. SRAM, antifusibles et Flash – voir les notes de cours, section 3.7.7.
f. La mémoire bloc est composée de modules spécifiques intercalés à travers les blocs de logique configu-
rable du FPGA. La mémoire distribuée utilise les ressources internes de blocs de logique configurable.
Considérez l’extrait de code VHDL suivant et les valeurs des signaux CLK1, CLK2, reset et A montrés
sur le chronogramme de la page suivante.
Complétez le chronogramme pour les signaux et variables T, U, V et F. Remettez la page avec votre ca-
hier d’examen.
library IEEE;
entity VHDLEstMonAmi is
port (
clk1, clk2, reset : in std_logic;
A: in integer;
F : out integer
);
end VHDLEstMonAmi;
architecture jaimeVHDL of VHDLEstMonAmi is

signal T, U : integer := -5;
begin
process (clk1)
variable V : integer := 3;
begin
if reset = '1' then
T <= 0;
elsif (rising_edge(clk1)) then
T <= T + V;
V := V + 2;
end if;
end process;
process (clk2)
begin
if clk2 = '1' then
U <= 5;
else
U <= A + T;
F <= U;
end if;
end if;
end process;
end jaimeVHDL;
Question 6 - Compléter et remettre cette page avec votre cahier d’examen
Nom : ___________________________________ Matricule : __________________________
50 ns
50
40 ns
30 ns
20
20 ns
10 ns
10
CLK1
CLK2
reset
U
A
V
T
Solution :
La variable V ne dépend d’aucun autre signal. Sa valeur initiale est 3, spécifiée lors de sa déclaration. Elle
est mise à jour lors de transitions positives du signal clk1, sauf lors d’un reset où elle conserve sa valeur.
Le signal T dépend de V. Sa valeur initiale est -5, spécifiée lors de sa déclaration. Il est mis à jour lors de
transitions positives du signal clk1. La valeur de V utilisée pour le calcul est celle de la dernière itération
du processus. Lors d’un reset, il prend la valeur 0.
Le signal U dépend de T et de A. Sa valeur initiale est -5, spécifiée lors de sa déclaration. Il est mis à jour
lors de transitions positives du signal clk2, parce que clk2 est dans la liste de sensitivité du processus et
qu’on a ajouté la condition (if clk2 = ‘1’). Attention, le résultat de la synthèse serait différent de celui de
la simulation. Lors d’un reset, il prend la valeur 5.
Le signal F dépend uniquement de U. Sa valeur initiale est -231, parce que son type est integer et qu’on ne
spécifie pas de valeur par défaut. Il est mis à jour lors de transitions positives du signal clk2, parce que
clk2 est dans la liste de sensitivité du processus et qu’on a ajouté la condition (if clk2 = ‘1’). Attention, le
résultat de la synthèse serait différent de celui de la simulation. La valeur assignée à F est celle de U lors
de la dernière exécution du processus.
Examen intra
Durée: 2h.
Pondération: 20%.
 Répondre sur le questionnaire et le remettre.
0100, 0101, 0110, 0111, 1000, 1001}.
dix. Dans le premier cas, aucune action n’est requise. Dans le deuxième cas, il faut ajouter +6 à la somme
3 0011
+4 +0100
07 0|0111 ← somme inférieure à dix, résultat correct (retenue 0, somme 7)

7 0111
+8 +1000
15 0|1111 ← somme supérieure à 9, il faut ajouter +6
+0110 +6
1|0101 ← résultat correct, retenue de 1, somme de 5

9 1001
+8 +1000
+0110 +6
Solution :
oper1 oper2
(4 bits) (4 bits)
retenue
(1 bit) additionneur
cin
à 4 bits
somme intermédiaire
(4 bits)
bit unique
6 0
>= 10?
bus de 4 bits
1 0
cout
additionneur
0
à 4 bits
somme
(4 bits)
b. (3 points) Donnez le code VHDL correspondant à votre diagramme.

Solution :
library IEEE;
entity addBCD is
port (
oper1, oper2 : in unsigned(3 downto 0);
somme : out unsigned(3 downto 0);
cout : out std_logic
);
end addBCD;
architecture arch1 of addBCD is

begin
process(oper1, oper2)
variable t : unsigned(4 downto 0);
begin
t := ('0' & oper1) + ('0' & oper2);
if (t > 9) then
t := t + 6;
end if;
somme <= t(3 downto 0);
cout <= t(4);
end process;
end arch1;
Considérez le diagramme d’états suivant, ainsi que du code VHDL partiel.

Complétez le code VHDL pour correspondre au diagramme d’états.
library IEEE;
reset x=00
entity controle201101Q2 is
port ( S1 S3
reset, CLK : in STD_LOGIC; Sortie <= 1 x=11 Sortie <= 0
);
end controle201101Q2; x=01 x=11 x=10
architecture arch of controle201101Q2 is
-- Votre code ici
-- Solution S2 S4
type type_etat is (S1, S2, S3, S4); Sortie <= 0 Sortie <= 1
signal etat : type_etat := S1; x=10
begin
-- Votre code ici
-- Solution
begin
etat <= S1;
case etat is
when S1 =>
if x = "00" then
etat <= S3;
elsif x = "01" then
etat <= S2;
end if;
when S2 | S3 =>
if x = "10" then
etat <= S4;
elsif x = "11" then
etat <= S1;
end if;
when S4 =>
etat <= S1;
when others =>
etat <= S1;
end case;
end if;
end process;
process(x, etat)
begin
case etat is
when S1 | S4 =>
sortie <= '1';
when others =>
sortie <= '0';
end case;
end process;
end arch;
a. K1: S ← (S + sll A, B) * C;
(où sll X, Y veut dire : faire un décalage logique vers la gauche du registre X du nombre de bits spécifié
par le registre Y)
K1
charge
D Q D Q
A décaleur S
CLK CLK
compte
D Q
CLK
D Q
CLK
b. K2K1: R2 ← R0 + R1, K2K1’: R2 ← R0 + R3


Expliquez les étapes suivies par un synthétiseur pour interpréter le code et inférer les structures matériel-
les nécessaires pour réaliser la fonction décrite.
library ieee;
entity decodeur38 is
port(
A : in std_logic_vector(2 downto 0);
F: out std_logic_vector(7 downto 0)
);
end decodeur38;
architecture flotDeDonnees of decodeur38 is
begin
with A select F <=
"00000001" when "000",
"00000010" when "001",
"00000100" when "010",
"00001000" when "011",
"00010000" when "100",
"00100000" when "101",
"01000000" when "110",
"10000000" when "111",
end flotDeDonnees;
Solution:
1. Le synthétiseur débute par une analyse des entrées et sorties du module. Il y a 3 entrées et 8 sorties.
Chaque sortie peut être considérée comme une fonction indépendante.
2. L’énoncé « with-select » spécifie la valeur de chacune des sorties pour toutes les combinaisons possi-
bles d’entrées. La table de vérité de chacune des fonctions de sortie est établie.
3. À partir de la table de vérité, une équation réduite est produite pour chaque fonction.
4. On doit spécifier au synthétiseur les blocs matériels disponibles en spécifiant par exemple la famille de
FPGA utilisé. À partir de cette librairie de blocs, chaque fonction est spécifiée en termes de ces blocs et
des interconnexions entre eux.
Note : L’assignation (others => ‘X’) n’est pas considérée par le synthétiseur, cet énoncé n’est pas synthé-
tisable.
Question 5. (2 points) Réponses brèves.
a. (0.5 point) Donnez un diagramme simplifié du flot de conception que vous avez suivi dans les labora-
toires du cours à ce jour.
b. (0.5 point) Énumérez quatre (4) éléments fondamentaux qu’on peut retrouver sur un FPGA présente-
ment en vente sur le marché.
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
c. (0.5 point) Lequel des énoncés suivants est vrai concernant des entités et architectures en VHDL?
iv. un module peut avoir plusieurs déclarations d’entité et plusieurs architectures.
d. (0.5 point) Lequel/lesquels des énoncés suivants est/sont vrai(s) concernant VHDL?
cessus.
Solutions
a. fig. 4.1 des notes de cours simplifiée : code VHDL et schémas -> vérification par simulation -> synthè-
b. Blocs de logique programmable (CLB), blocs d’entrées-sorties (IOB), réseau d’interconnexions, cir-
cuits de routage rapide des retenues, blocs de mémoire intégrée, blocs de fonctions arithmétiques avan-
cées (multiplicateurs, multiplicateurs-accumulateurs), microprocesseurs fixes, circuits de génération et de
distribution d’horloge. Éléments moins fondamentaux : LUT, flip-flop, multiplexeur.
c. ii. Une entité, plusieurs architectures
d. i, iii, iv, v.
library ieee;
entity monModule5 is
port (
A, B, C, D : in std_logic;
sortie : out std_logic_vector(1 downto 0)
);
end monModule5;

signal etat : std_logic_vector(1 downto 0);
begin
begin
etat <= "00";
etat(1) <= (A and B and C) or D;
etat(0) <= A and not(D);
sortie(1) <= B and etat(0);
end if;
end process;
sortie(0) <= '0' when (etat = "01" or etat = "10") else '1';
end arch;
Question 6
Nom : ____________________________ Matricule : __________________________
G4
YQ
G3 D Q
Table de
conversion
G2 G reset
16 X 1 S0
G1
H1 S1
F4
XQ
F3 D Q
Table de
conversion
F2 F reset
16 X 1 S2
F1
S3
CLK
reset
G4
YQ
G3 D Q
Table de
conversion
G2 G reset
16 X 1 S0
G1
H1 S1
F4
XQ
F3 D Q
Table de
conversion
F2 F reset
16 X 1 S2
F1
S3
CLK
reset
Question 6
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
Solution
G4
A YQ
G3 D Q Etat(1)
B Table de
conversion
G2 G
C 16 X 1 S0 reset
G1
D
Y
H1 S1
F4
A XQ
F3 D Q Etat(0)
D Table de
conversion
F2 F reset
16 X 1 S2
F1
S3
CLK
reset
G4
Etat(0) D Q
YQ
Sortie(1)
G3
Table de
B conversion
G2 G reset
16 X 1 S0
G1
H1 S1
F4
Etat(1) D Q
XQ
F3
Table de
Etat(0) conversion
F2 F reset
16 X 1 S2
F1
X
Sortie(0)
S3
CLK
reset
Solution
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 1 0
0 0 1 0 0 0 0 1 0 0
0 0 1 1 1 0 0 1 1 0
0 1 0 0 0 0 1 0 0 0
0 1 0 1 1 0 1 0 1 0
0 1 1 0 0 0 1 1 0 0
0 1 1 1 1 0 1 1 1 0
1 0 0 0 0 1 0 0 0 1
1 0 0 1 1 1 0 0 1 1
1 0 1 0 0 1 0 1 0 1
1 0 1 1 1 1 0 1 1 1
1 1 0 0 0 1 1 0 0 0
1 1 0 1 1 1 1 0 1 0
1 1 1 0 1 1 1 1 0 0
1 1 1 1 1 1 1 1 1 0
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 0 1 1
0 0 1 0 0 0 0 1 0 1
0 0 1 1 0 0 0 1 1 1
0 1 0 0 0 0 1 0 0 0
0 1 0 1 0 0 1 0 1 0
0 1 1 0 0 0 1 1 0 0
0 1 1 1 0 0 1 1 1 0
1 0 0 0 0 1 0 0 0 0
1 0 0 1 0 1 0 0 1 0
1 0 1 0 0 1 0 1 0 0
1 0 1 1 0 1 0 1 1 0
1 1 0 0 1 1 1 0 0 1
1 1 0 1 1 1 1 0 1 1
1 1 1 0 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1
Examen intra
Durée: 2h.
Pondération: 20%.
 Répondre sur le questionnaire et le remettre.
0100, 0101, 0110, 0111, 1000, 1001}.
dix. Dans le premier cas, aucune action n’est requise. Dans le deuxième cas, il faut ajouter +6 à la somme
3 0011
+4 +0100
07 0|0111 ← somme inférieure à dix, résultat correct (retenue 0, somme 7)

7 0111
+8 +1000
+0110 +6

9 1001
+8 +1000
+0110 +6
Solution :
oper1 oper2
(4 bits) (4 bits)
retenue
(1 bit) additionneur
cin
à 4 bits
somme intermédiaire
(4 bits)
bit unique
6 0
>= 10?
bus de 4 bits
1 0
cout
additionneur
0
à 4 bits
somme
(4 bits)
b. (3 points) Donnez le code VHDL correspondant à votre diagramme.

Solution :
library IEEE;
entity addBCD is
port (
oper1, oper2 : in unsigned(3 downto 0);
somme : out unsigned(3 downto 0);
cout : out std_logic
);
end addBCD;
architecture arch1 of addBCD is

begin
process(oper1, oper2)
variable t : unsigned(4 downto 0);
begin
t := ('0' & oper1) + ('0' & oper2);
if (t > 9) then
t := t + 6;
end if;
somme <= t(3 downto 0);
cout <= t(4);
end process;
end arch1;
Considérez le diagramme d’états suivant, ainsi que du code VHDL partiel.

Complétez le code VHDL pour correspondre au diagramme d’états.
library IEEE;
reset x=00
entity controle201101Q2 is
port ( S1 S3
reset, CLK : in STD_LOGIC; Sortie <= 1 x=11 Sortie <= 0
);
end controle201101Q2; x=01 x=11 x=10
architecture arch of controle201101Q2 is
-- Votre code ici
-- Solution S2 S4
type type_etat is (S1, S2, S3, S4); Sortie <= 0 Sortie <= 1
signal etat : type_etat := S1; x=10
begin
-- Votre code ici
-- Solution
begin
etat <= S1;
case etat is
when S1 =>
if x = "00" then
etat <= S3;
elsif x = "01" then
etat <= S2;
end if;
when S2 | S3 =>
if x = "10" then
etat <= S4;
elsif x = "11" then
etat <= S1;
end if;
when S4 =>
etat <= S1;
when others =>
etat <= S1;
end case;
end if;
end process;
process(x, etat)
begin
case etat is
when S1 | S4 =>
sortie <= '1';
when others =>
sortie <= '0';
end case;
end process;
end arch;
a. K1: S ← (S + sll A, B) * C;
(où sll X, Y veut dire : faire un décalage logique vers la gauche du registre X du nombre de bits spécifié
par le registre Y)
K1
charge
D Q D Q
A décaleur S
CLK CLK
compte
D Q
CLK
D Q
CLK
b. K2K1: R2 ← R0 + R1, K2K1’: R2 ← R0 + R3


Expliquez les étapes suivies par un synthétiseur pour interpréter le code et inférer les structures matériel-
les nécessaires pour réaliser la fonction décrite.
library ieee;
entity decodeur38 is
port(
A : in std_logic_vector(2 downto 0);
F: out std_logic_vector(7 downto 0)
);
end decodeur38;
architecture flotDeDonnees of decodeur38 is
begin
with A select F <=
"00000001" when "000",
"00000010" when "001",
"00000100" when "010",
"00001000" when "011",
"00010000" when "100",
"00100000" when "101",
"01000000" when "110",
"10000000" when "111",
end flotDeDonnees;
Solution:
1. Le synthétiseur débute par une analyse des entrées et sorties du module. Il y a 3 entrées et 8 sorties.
Chaque sortie peut être considérée comme une fonction indépendante.
2. L’énoncé « with-select » spécifie la valeur de chacune des sorties pour toutes les combinaisons possi-
bles d’entrées. La table de vérité de chacune des fonctions de sortie est établie.
3. À partir de la table de vérité, une équation réduite est produite pour chaque fonction.
4. On doit spécifier au synthétiseur les blocs matériels disponibles en spécifiant par exemple la famille de
FPGA utilisé. À partir de cette librairie de blocs, chaque fonction est spécifiée en termes de ces blocs et
des interconnexions entre eux.
Note : L’assignation (others => ‘X’) n’est pas considérée par le synthétiseur, cet énoncé n’est pas synthé-
tisable.
Question 5. (2 points) Réponses brèves.
a. (0.5 point) Donnez un diagramme simplifié du flot de conception que vous avez suivi dans les labora-
toires du cours à ce jour.
b. (0.5 point) Énumérez quatre (4) éléments fondamentaux qu’on peut retrouver sur un FPGA présente-
ment en vente sur le marché.
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
___________________________________________________________________________________
c. (0.5 point) Lequel des énoncés suivants est vrai concernant des entités et architectures en VHDL?
iv. un module peut avoir plusieurs déclarations d’entité et plusieurs architectures.
d. (0.5 point) Lequel/lesquels des énoncés suivants est/sont vrai(s) concernant VHDL?
cessus.
Solutions
a. fig. 4.1 des notes de cours simplifiée : code VHDL et schémas -> vérification par simulation -> synthè-
b. Blocs de logique programmable (CLB), blocs d’entrées-sorties (IOB), réseau d’interconnexions, cir-
cuits de routage rapide des retenues, blocs de mémoire intégrée, blocs de fonctions arithmétiques avan-
cées (multiplicateurs, multiplicateurs-accumulateurs), microprocesseurs fixes, circuits de génération et de
distribution d’horloge. Éléments moins fondamentaux : LUT, flip-flop, multiplexeur.
c. ii. Une entité, plusieurs architectures
d. i, iii, iv, v.
library ieee;
entity monModule5 is
port (
A, B, C, D : in std_logic;
sortie : out std_logic_vector(1 downto 0)
);
end monModule5;

signal etat : std_logic_vector(1 downto 0);
begin
begin
etat <= "00";
etat(1) <= (A and B and C) or D;
etat(0) <= A and not(D);
sortie(1) <= B and etat(0);
end if;
end process;
sortie(0) <= '0' when (etat = "01" or etat = "10") else '1';
end arch;
Question 6
Nom : ____________________________ Matricule : __________________________
G4
YQ
G3 D Q
Table de
conversion
G2 G reset
16 X 1 S0
G1
H1 S1
F4
XQ
F3 D Q
Table de
conversion
F2 F reset
16 X 1 S2
F1
S3
CLK
reset
G4
YQ
G3 D Q
Table de
conversion
G2 G reset
16 X 1 S0
G1
H1 S1
F4
XQ
F3 D Q
Table de
conversion
F2 F reset
16 X 1 S2
F1
S3
CLK
reset
Question 6
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 1 0 0 1 1
0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 1 1 0 1 1 1
1 0 0 0 1 0 0 0
1 0 0 1 1 0 0 1
1 0 1 0 1 0 1 0
1 0 1 1 1 0 1 1
1 1 0 0 1 1 0 0
1 1 0 1 1 1 0 1
1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1
Solution
G4
A YQ
G3 D Q Etat(1)
B Table de
conversion
G2 G
C 16 X 1 S0 reset
G1
D
Y
H1 S1
F4
A XQ
F3 D Q Etat(0)
D Table de
conversion
F2 F reset
16 X 1 S2
F1
S3
CLK
reset
G4
Etat(0) D Q
YQ
Sortie(1)
G3
Table de
B conversion
G2 G reset
16 X 1 S0
G1
H1 S1
F4
Etat(1) D Q
XQ
F3
Table de
Etat(0) conversion
F2 F reset
16 X 1 S2
F1
X
Sortie(0)
S3
CLK
reset
Solution
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 1 0
0 0 1 0 0 0 0 1 0 0
0 0 1 1 1 0 0 1 1 0
0 1 0 0 0 0 1 0 0 0
0 1 0 1 1 0 1 0 1 0
0 1 1 0 0 0 1 1 0 0
0 1 1 1 1 0 1 1 1 0
1 0 0 0 0 1 0 0 0 1
1 0 0 1 1 1 0 0 1 1
1 0 1 0 0 1 0 1 0 1
1 0 1 1 1 1 0 1 1 1
1 1 0 0 0 1 1 0 0 0
1 1 0 1 1 1 1 0 1 0
1 1 1 0 1 1 1 1 0 0
1 1 1 1 1 1 1 1 1 0
G4 ( ) G3 ( ) G2 ( ) G1 ( ) G() F4 ( ) F3 ( ) F2 ( ) F1 ( ) F()
0 0 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 0 1 1
0 0 1 0 0 0 0 1 0 1
0 0 1 1 0 0 0 1 1 1
0 1 0 0 0 0 1 0 0 0
0 1 0 1 0 0 1 0 1 0
0 1 1 0 0 0 1 1 0 0
0 1 1 1 0 0 1 1 1 0
1 0 0 0 0 1 0 0 0 0
1 0 0 1 0 1 0 0 1 0
1 0 1 0 0 1 0 1 0 0
1 0 1 1 0 1 0 1 1 0
1 1 0 0 1 1 1 0 0 1
1 1 0 1 1 1 1 0 1 1
1 1 1 0 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1
Question 1. (2.5 points)
a. Considérez le processeur d’usage général présenté dans les notes de cours. L’architecture de son
chemin de données est illustrée à la Figure 1. Les extraits du code VHDL donnés ci-après rappellent
le fonctionnement de l’ALU et de la mémoire.
choixSource
registre d’état
0 état
constante 1 donnée
entréeExterne 2 A A
3
sortie bloc des registres UAL F
adresse
choixCharge B B
mémoire des données
charge
clk
choixA choixB opération
lecture/ecriture’
entree
clk
sortieExterne
Figure 1
-- dans la partie déclarative
signal F : signed(Wd - 1 downto 0);
signal Z : std_logic;
signal N : std_logic;
signal op : integer range 0 to 7;
type memoireDonnees_type is array(0 to 2 ** Md - 1) of signed(Wd - 1 downto 0);

signal memoireDonnees : memoireDonnees_type;
signal sortieMemoireDonnees : signed(Wd - 1 downto 0);
signal adresseMemoireDonnees : integer range 0 to 2 ** Md - 1;
signal lectureEcritureN : std_logic;
-- dans le corps de l'architecture

process(A, B, op)
begin
case op is
when 0 => F <= A + B;
when 1 => F <= A - B;
when 2 => F <= shift_right(A, 1);
when 3 => F <= shift_left(A, 1);
when 4 => F <= not(A);
when 5 => F <= A and B;
when 6 => F <= A or B;
when 7 => F <= A;
when others => F <= (others => 'X');
end case;
end process;
process (CLK)
begin
if lectureEcritureN = '0' then
memoireDonnees(adresseMemoireDonnees) <= B;
end if;
end if;
end process;
sortieMemoireDonnees <= memoireDonnees(adresseMemoireDonnees);
b. Complétez la table suivante, en donnant les instructions selon les valeurs des signaux de contrôle indi-
quées.
Lecture/Écriture
choixCharge
choixSource
opération
Instruction
choixA
choixB
charge
R2<-R4 0 2 1 4 - 7 1
M[addr] <-R2 - - 0 - 2 - 0
R3<-R1+R4 0 3 1 1 4 0 1
R4<-M[addr] 3 4 1 - - - 1
Table 1
Considérez le processeur à usage général décrit dans les notes de cours, sections 8.6 à 8.8 inclusivement.
Ajoutez une instruction de la forme Rk ← #WXYZ, permettant de charger le registre k avec une valeur
immédiate de 16 bits de large (WXYZ représente 4 chiffres hexadécimaux). Cette instruction nécessite
deux mots de 16 bits dans la séquence des instructions : le premier représente l’instruction (chargement de
valeur immédiate de 16 bits) et le deuxième contient la valeur WXYZ.
c. Modifiez le diagramme d’états de l’unité de contrôle donné à l'Annexe I pour ajouter cette nouvelle
instruction.
Après l’état de décodage il faut ajouter un état pour exécuter la nouvelle instruction.
d. Donnez l’encodage de votre nouvelle instruction. Au besoin, inspirez-vous du tableau 2.
TABLE 2
Une solution : 1010 | destination | - | -
Question2. (3 points) Un système embarqué équipé d’un processeur à but spécifique contrôle l’entrée
dans un garage. L’entrée est permise si deux jetons sont déposés par les conducteurs. Donnez le schéma
du chemin de donné et la machine à états de l’unité de contrôle de ce système. Le système a une entrée
qui indique la présence d’un jeton et un signal de sortie pour accorder l’accès.
Soit le circuit représenté à la Figure 3. Les bascules ont un temps de préparation de 1 ns, un temps de
maintien de 0.5 ns et un délai de propagation de 2 ns. Le temps de propagation dans les portes ET, OU,
XOR et INV de 3 ns, 3 ns, 4 ns, 1 ns respectivement. Négligez les délais des interconnexions.
a. Déterminez la fréquence maximale d’horloge.

Pour déterminer la période minimale de chaque chemin: T = tcomb+tsu+td
A vers F: T=3+3+2+1 = 9ns
B vers F: T=1+1+3+2+1= 8ns
B vers G: T=4+4+1+2+1= 12 ns
C vers G: T=3+3+4+1+2+1= 14 ns
D vers G: T=3+3+4+1+2+1= 14 ns
E vers G: T=3+3+4+1+2+1=14ns
F vers A: T=3+2+1=6ns
G vers A: T=2+3+1=6ns
Le chemin le plus long fait 14 ns. La fréquence maximale du circuit est donc 1/14ns= 71.4Mhz
b. Déterminez la marge libre de préparation de chaque chemin.
A vers F: 5ns
B vers F: 6ns
B vers G: 2ns
C vers G: 0ns
D vers G: 0ns
E vers G: 0ns
F vers A: 8ns
G vers A: 8ns
c. Quelles sont les bornes minimales et maximales du déphasage d’horloge acceptables tout en ga-
rantissant cette fréquence maximale?
T>= tcomb+tsu+td-tcs d'où la borne tcs >= tcomb+tsu+td-T
tcomb +td-tcs>th d'où la borne tcs < tcomb+td-th
A vers F: -5ns<=tcs<7.5ns
B vers F: -6ns<=tcs<6.5ns
B vers G: -2 ns <= tcs <10.5ns
C vers G: 0ns<=tcs<12.5ns
D vers G: 0ns<=tcs<12.5ns
E vers G: 0ns<=tcs<12.5ns
F vers A: -8ns<=tcs<4.5ns
G vers A: -8ns<=tcs<4.5ns
Pour que le circuit continue de bien fonctionner, les bornes de déphasage acceptables sont:
0ns<=tcs<4.5ns
d. En considérant un déphasage d’horloge nul, modifiez le circuit donné à l'Annexe II de sorte à ajouter
un étage de pipeline permettant d’augmenter la fréquence maximale. Déterminez la nouvelle fréquence
maximale.
A
F
C
G
CLK DÉPHASAGE
Question 4. (2.5 points)
a. Considérez le code suivant pour un module combinatoire et son banc de test.
library IEEE;
entity module3 is
port (
F, G : out std_logic
);
end module3;
architecture arch of module3 is

signal S, T, U : std_logic;
begin
S <= A or B;
T <= A xor B;
U <= A and C;
process (S, T)
begin
F <= S and T;
end process;
process (C)
begin
G <= C or U;
end process;
end arch;
library ieee;
entity module3_TB is
end module3_TB;
architecture arch of module3_TB is

signal A, B, C, F, G : std_logic;
begin
UUT : entity module3(arch) port map (A, B, C, F, G);
B <= '0' after 0 ns;
C <= '0' after 0 ns, '1' after 10 ns;
end arch;
Donnez la liste des événements dressée par un simulateur qui exécute le banc d’essai.

À t = 0 + 2 Δ, évaluation des signaux S, T, U et G (provoquées par les changements sur A, B, C)
À t = 0 + 3 Δ, évaluation de F (provoquées par les changements sur S, T, U) ** mais pas d’évaluation de
F parce que U n’est pas dans la liste de sensitivité du processus **
À t = 10 ns + 0 Δ, assignation de 1 à C
À t = 10 ns + 1 Δ, évaluation de U (provoquée par le changement sur C),
b. Discutez l’utilisation des boucles et conditions dans un code VHDL synthétisable.

•À l’intérieur d’un processus, on peut utiliser des boucles et des conditions pour modéliser le comporte-
ment d’un circuit.
•Les boucles sont une manière compacte de représenter plusieurs énoncés reliés logiquement entre eux.
•Les paramètres d’exécution de la boucle doivent prendre des valeurs statiques au moment de la synthèse.
•Les boucles sont implémentées en les déroulant: les énoncés d’assignation qu’elles contiennent sont ré-
pliqués, un pour chaque itération de la boucle.
•Pour les circuits combinatoires, les conditions permettent d’effectuer un choix.
–L’énoncé case a l’avantage de représenter des choix qui sont mutuellement exclusifs et qui ont la même
préséance. Il correspond assez exactement à l’action d’un multiplexeur.
–L’énoncé if, est plus général avec les clauses elsif ainsi qu’une clause else. Il est possible de l’utiliser
pour donner préséance à certaines conditions par rapport à d’autres. Cela peut résulter en un circuit plus
complexe que nécessaire, parce que le comportement décrit peut être plus restrictif que ce que le concep-
teur a en tête.
Question 5 (4 points)
Au laboratoire, vous avez eu à concevoir un processeur à usage général dont les instructions tiennent sur
28 bits, et dont la déclaration d'entité suit. Le jeu d'instructions de ce processeur est donné à l'Annexe I.
entity processeurv20 is
generic (
Nreg : integer := 32; -- nombre de registres
Wd : integer := 16; -- largeur du chemin des données en bits
Wi : integer := 28; -- largeur des instructions en bits
Mi : integer := 12; -- nombre de bits d'adresse de la mémoire d'instructions
Md : integer := 8; -- nombre de bits d'adresse de la mémoire des données
resetvalue : std_logic := '1'
);
port(
clk : in std_logic;
entreeExterne : in signed(Wd - 1 downto 0);
fifoInNotReady : in std_logic;
reqEntreeExterne : out std_logic;
sortieExterne : out signed(Wd - 1 downto 0);
fifoOutNotReady : in std_logic;
ecrireSortieExterne : out std_logic
);
end processeurv20;
a. Quelle sera la valeur du registre r0 à la fin de l'exécution de ce programme ?
constant memoireInstructions : memoireInstructions_type :=
(x"A080018", -- r8 <- +24 / addr x00
x"A090001", -- r9 <- +1 / addr x01
x"A000000", -- r0 <- +0 / addr x02
x"9000000", -- M[r0] <- r0 / addr x03
x"0000009", -- r0 <- r0 + r9 / addr x04
x"9000000", -- M[r0] <- r0 / addr x05
x"0000009", -- r0 <- r0 + r9 / addr x06
x"10A0008", -- rA <- r0 - r8 / addr x07
x"C040012", -- jump to addr x12 si N = '0' / addr x08
x"1000009", -- r0 <- r0 - r9 / addr x09
x"8020000", -- r2 <- M[r0] / addr x0A
x"1000009", -- r0 <- r0 - r9 / addr x0B
x"8010000", -- r1 <- M[r0] / addr x0C
x"0000009", -- r0 <- r0 + r9 / addr x0D
x"0000009", -- r0 <- r0 + r9 / addr x0E
x"0030102", -- r3 <- r1 + r2 / addr x0F
x"9000003", -- M[r0] <- r3 / addr x10
x"C000006", -- jump to addr x06 / addr x11
x"1000009", -- r0 <- r0 - r9 / addr x12
x"8000000", -- r0 <- M[r0] / addr x13
others => (others => '1'));
Le registre r0 aura la valeur 28 657.
b. Quel est le nombre de cycles d'horloge nécessaire à l'exécution du programme ? Justifiez clairement
votre réponse en énonçant vos hypothèses de travail.
D'abord nous devons évaluer le nombre d'instructions qui seront exécutées. Les instructions x01 à x05
seront exécutées exactement 1 fois chacune car elles sont en dehors de la boucle du programme. Il en est
de même pour les instructions x13 et x14. Les instructions x09 à x11 seront exécutées 22 fois. Les ins-
tructions x06 à x08 seront exécutées 23 fois (une fois de plus que les instructions de la boucle, la dernière
intervenant quand le programme sort de la boucle). Nous avons par conséquent un total de 5 + 2 + 22(9) +
23(3) = 274 instructions. Chaque instruction nécessite 3 cycles d'horloge, on obtient 822 cycles d'horloge.
c. Décrivez dans un pseudo-code le plus lisible possible l'algorithme précédent. On supposera que l'algo-
rithme retourne la valeur du registre r0.
M[0] ← 0;
M[1] ← 1;
Pour i = 2 à 23
M[i] ← M[i-1] - M[i-2];
Fin Pour
return M[23];
d. Il n'est pas nécessaire pour exécuter ce programme de recourir à la mémoire de données. Proposez un
programme qui exécute le même algorithme sans utiliser la mémoire de données. Vous êtes libre d'utiliser
tous les registres à votre disposition mais vous devez absolument vous assurer que le résultat de votre
programme se retrouve au registre r0 à la fin de son exécution.
constant memoireInstructions : memoireInstructions_type :=
(x"A080018", -- r8 <- +24 / addr x00
x"A090001", -- r9 <- +1 / addr x01
x"A010000", -- r1 <- +0 / addr x02
x"A000001", -- r0 <- +1 / addr x03
x"A030002", -- r3 <- +2 / addr x04
x"10A0308", -- rA <- r3 - r8 / addr x05
x"C04000C", -- jump to addr x0C si N = '0' / addr x06
x"7020000", -- r2 <- r0 / addr x07
x"0000100", -- r0 <- r1 + r0 / addr x08
x"7010200", -- r1 <- r2 / addr x09
x"0030309", -- r3 <- r3 + r9 / addr x0A
x"C000005", -- jump to addr x05 / addr x0B
others => (others => '1'));
Question 6 (4 points)
On vous demande de réaliser un circuit permettant de trouver la valeur médiane de trois nombres signés
donnés en entrée : a, b et c. Ainsi, si (a, b, c) = (+3, +8, +5), la sortie devrait être z = +5. Si (a, b, c) =
(+3, +8, +3), la sortie devrait être z = +3. Si (a, b, c) = (+8, +8, +3), la sortie devrait être z = +8.
library ieee;
entity mediane3 is
generic(
w : positive := 8
);
port(
a : in signed(w-1 downto 0);
b : in signed(w-1 downto 0);
c : in signed(w-1 downto 0);
z : out signed(w-1 downto 0)
);
end mediane3;
a) Écrivez le code VHDL synthétisable de l’entité mediane3.

architecture arch of mediane3 is
begin
process( a, b, c ) is
variable max_1 : signed(w-1 downto 0);
variable max_2 : signed(w-1 downto 0);
begin
if( a > b ) then

max_1 := a;
max_2 := b;
else
max_1 := b;
max_2 := a;
end if;
if( c >= max_1 ) then

z <= max_1;
elsif( c < max_2 ) then
z <= max_2;
else
z <= c;
end if;
end process;
end arch;
b) Quelle est la plus petite taille de l'ensemble de vecteurs de test permettant d'effectuer un test exhaustif
de l’entité mediane3 lorsque w=8 ? Justifiez votre réponse par un calcul.
Comme il y a 3 entrées, l'ensemble contient au minimum 23w = 224 ≥ 16 millions vecteurs de test.
On vous propose trois classes pour chacune des entrées du circuit mediane3 (on suppose w≥2) :
{ {–2w-1, –2w-1 + 1, … –2w-2 – 1},
{–2w-2, … +2w-2 – 1},
{+2w-2, +2w-2+1, … +2w-1 – 1} }
c) Quelle est la taille minimale de l'ensemble de vecteurs de test permettant d'effectuer un test faible sur
l’entité mediane3, et ce en recourant aux classes identifiées précédemment. Justifiez votre réponse et
proposez un exemplaire d'un tel vecteur de test pour w = 8.
Pour effectuer un test faible, il faut qu'au moins un représentant de chaque classe apparaisse une fois, et
ce pour l'ensemble des entrées. Comme nous avons trois classes pour chaque entrée, l'ensemble permet-
tant d'effectuer un test faible peut contenir au minimum 3 vecteurs test.
Un exemple d'un tel ensemble est {{-127, 0, +127}, {0, +127, -127}, {+127, -127, 0}}
d) Quelle est la taille minimale de l'ensemble de vecteurs de test permettant d' effectuer un test fort sur
l’entité mediane3, et ce en recourant aux classes identifiées précédemment. Justifiez votre réponse et
proposez un exemplaire d'un tel vecteur de test pour w = 8.
Pour effectuer un test fort, il faut que toutes les combinaisons des classes de chaque entrées soit considé-
rées au moins une fois. Comme nous avons trois classes pour chaque entrée, l'ensemble permettant d'ef-
fectuer un test fort peut contenir au minimum 33 = 27 vecteurs de test.
Un exemple d'un tel ensemble est :
{{-127, -127, -127}, {-127, -127, 0}, {-127, -127, +127}, {-127, 0, -127}, {-127, 0, 0},
{-127, 0, +127},{-127, +127, -127}, {-127, +127, 0}, {-127, +127, +127}, {0, -127, -127}, {0, -127, 0},
{0, -127, +127}, {0, 0, -127}, {0, 0, 0}, {0, 0, +127},{0, +127, -127}, {0, +127, 0},
{0, +127, +127},{+127, -127, -127}, {+127, -127, 0}, {+127, -127, +127}, {+127, 0, -127}, {+127, 0, 0},
{+127, 0, +127},{+127, +127, -127}, {+127, +127, 0}, {+127, +127, +127}}
e) Quelle est la couverture de branchement de l'implémentation proposée à la question (a) telle en utili-
sant l'ensemble de vecteurs de test que proposé à question (d). Justifiez adéquatement votre réponse.
Comme on considère un test fort, la couverture de branchement sera de100 %.
Examen intra
Mercredi 20 février 2013
Durée: 2h.
Pondération: 20%.
 Remettre le questionnaire avec votre réponse à la question 2.
 Ne posez pas de question durant l'examen. En cas de doute sur le sens d’une question, énoncez
clairement toute supposition que vous faites.
Considérez le code VHDL suivant décrivant un circuit combinatoire:

library ieee;
entity question_1 is
port(
entree : in signed(9 downto 0);
sortie : out signed(9 downto 0)
);
end question_1;
architecture arch of question_1 is
-- déclaration de fonction
function gen_response(int_value : integer) return signed is
constant cst_1 : integer := 7;
constant w : positive := 10;
begin
return to_signed( (cst_1 * int_value + cst_2 * int_value)
mod
cst_3,
w);
end function gen_response;
-- déclaration de signal
signal a : signed(9 downto 0);
begin
-- process combinatoire
process( entree, a ) is
variable v : signed(9 downto 0);
begin
a <= gen_response( to_integer(entree) );

v := gen_response( to_integer(a) );
sortie <= a + v;
end process;
end arch;
a) Quelle est la valeur prise par le signal sortie lorsque entree vaut "1000010000". Rép. "0000000000"
b) Quelle est la valeur prise par le signal sortie lorsque entree vaut "0100000101".Rép. "0000000000"
c) Pour quelle(s) valeur du signal entree, sortie subit-elle un débordement suite à l'addition de a et v ?
Aucune. a = v = 0.
d) Ce code VHDL est-il synthétisable ? Justifiez votre réponse.
Le code est synthétisable. Il s'agit d'un circuit combinatoire impliquant addition, multiplication et modulo
sur une puissance de 2. De plus, le synthétiseur devrait se rendre compte que la sortie vaut toujours 0.
Considérez le code VHDL suivant. Complétez le chronogramme issu de cette description matérielle.
library ieee;
port(
rst_n : in std_logic;
clk : in std_logic;
a1, a2 : in std_logic;
z : out std_logic
);
end question_2;

-- déclaration de signaux
signal t1, t2, t3, t4 : std_logic;
begin
-- process 1
process( a1, a2 ) is
begin
t1 <= a1 or a2;
end process;
-- process 2
process( a1 ) is
begin
t2 <= a1 or a2;
end process;
-- process 3
process( a1 ) is
variable v : std_logic;
begin
v := a1;
t3 <= a1 or a2;
end process;
-- process 4
process( rst_n, clk) is
begin
if( rst_n = '0' ) then
t4 <= '0';
t4 <= a1 or a2;
end if;
end process;
-- sortie
z <= t1 xor t2 xor t3 xor t4;
end arch;
clk
rst
a1
a2
t1
t2
t3
t4
Considérez le code VHDL suivant décrivant un circuit séquentiel:

library ieee;
port (
clk : in std_logic;
entree : in std_logic;
sortie : out std_logic
);
end question_3;
type etats is (x, y, z, w);

signal etat : etats := x;
signal t_sortie : std_logic := '0';
begin
process(clk, reset) is
begin
if reset = '0' then
etat <= x;
t_sortie <= '0';
case etat is
when x =>
if ( entree = '1' ) then
etat <= w;
end if;
when y =>
etat <= z;
end if;
t_sortie <= '0';
when z =>
etat <= x;
end if;
t_sortie <= '0';
when others => -- w
etat <= z;
else
etat <= y;
end if;
t_sortie <= '1';
end case;
end if;
end process;
sortie <= entree xor t_sortie;
end arch;
a) S'agit-il d'une machine de Moore ou d'une machine de Mealy ? Justifiez votre réponse.
Il s'agit d'une machine de Mealy puisque la sortie dépend de l'entrée.
b) Dessinez le diagramme d'états de la machine à états.
Ce circuit peut s'interpréter comme un machine à états à 4 états auquel est adjoint un circuit séquentiel
constitué d'une bascule pour entreposer l'état du signal t_sortie. En supposant que les états de la premiè-
re machine sont encodés sur 2 bits, alors la machine à états totale (la machine de Mealy qui nous intéres-
se) possède jusqu'à 8 états. Une analyse du comportement de cette dernière indique que seuls 6 états de la
machine comptent (les autres états étant redondants). Le diagramme suivant illustre le comportement de
cette machine de Mealy:
1/1
0/0 x z0 0/0
1/0 0/1
1/1 z1 0/1 1/1
0/0
w y1 y0 0/0
1/1 1/0
c) Partant de l'état x, quel sera la sortie sortie de la machine après 3 fronts montant de l'horloge si on
maintient l'entrée entree à '1'. Quel sera l'état à ce moment là?
La sortie sera à 1. On sera à y.
d) Partant de l'état x, quel sera la sortie sortie de la machine après 3 fronts montant de l'horloge si on
maintient l'entrée entree à '0'. Quel sera l'état à ce moment là?
La sortie sera à 0. On sera à x.
En utilisant des registres, des multiplexeurs, décodeurs et autres circuits combinatoires vus en classe,
dessinez les chemins de données permettant de réaliser chacune des micro-opérations suivantes, où R0,
R1 et R2 sont des registres et K1, K2 sont des signaux de contrôle :
a) K1: R1 ← R1+R0
K1
charge
D Q D Q
R0 R1
CLK CLK
b) K1: R1 ← R1+R0 ; K1': R0 ← R1+R0
K1
charge
D Q
R0
CLK
K1
charge
D Q
R1
CLK
c) K1K2': R2 ← R1 ; K2: R2 ← R1+R2
K1 K2
K2
D Q 0 charge
D Q
R1 1
R2
CLK
CLK
d) K1K2: R2 ← sll R1, R2 ; K1K2’: R2 ← slr R1, R0
K1
charge
D Q D Q
R1 décaleur R2
CLK CLK
direction compte
K2
0
D Q
R0
CLK
On désire concevoir un circuit séquentiel qui prend N entrées binaires x1, x2, x3, ..., xN et qui calcule la
fonction logique v = (x1 + x2 + x3 +...+ xN), qu'il convient de lire comme v est la disjonction (OR) des en-
trées x1 à xN.
Les entrées xi arrivent de manière sérielle. Au début de la séquence, qui coïncide avec l'arrivée de x1, le
signal d'entrée start prend la valeur 1. À la fin de la séquence, qui coïncide avec l'arrivée de l'entrée xN, le
signal stop prend la valeur 1. Les signaux start et stop prennent la valeur 1 durant un cycle d'horloge seu-
lement durant une séquence d'entrée xi. Vous êtes assurés d'avoir au moins 2 éléments durant une séquen-
ce d'entrée (N ≥ 2).
Le résultat de l'opération v doit apparaître à la sortie en même temps que l'on met la sortie ready à 1. Le
signal ready demeure à 1 tant qu'une nouvelle séquence de traitement n'a pas débuté. Il vaut 0 quand le
circuit traite une nouvelle séquence.
Le schéma suivant devrait vous aider à saisir les ports d'entrées/sorties de l'entité que nous considérons.
start
ready
stop
v
xi
clk
a) Proposez un chemin de données permettant de réaliser ce circuit.
sel
1
x D Q v
0
CLK
EN CE
b) Décrivez en VHDL ce circuit séquentiel en exploitant le chemin de données proposé à la question 5.a.
library ieee;
port (
clk : in std_logic;
start : in std_logic;
stop : in std_logic;
x : in std_logic;
ready : out std_logic;
v : out std_logic
);
end question_5;

signal rdy : boolean := true;
signal sel : std_logic;
signal en : std_logic;
signal q : std_logic := '0';
begin
begin
if reset = '1' then
rdy <= true;
case rdy is
when true =>
if( start = '1' ) then
rdy <= false;
end if;
when false =>
if( stop = '1' ) then
rdy <= true;
end if;
end case;
end if;
end process;
sel <= '0' when rdy else '1';

en <= '0' when ( rdy and start = '0' ) else '1';
ready <= '1' when rdy else '0';
begin
if reset = '1' then
q <= '0';
if( en = '1' ) then
if( sel = '0' ) then
q <= x;
else
q <= q or x;
end if;
end if;
end if;
end process;
v <= q;
end arch;
Cette solution reprenait dans le détail le chemin de donnée et y ajoutait un contrôle. Voici une façon plus
conventionnelle de faire la même chose où les signaux sel et en sont inférés de la description HDL.
architecture arch2 of question_5 is

signal rdy : boolean := true;
signal q : std_logic := '0';
begin
begin
if reset = '1' then
rdy <= true;
case rdy is
when true =>
if( start = '1' ) then
rdy <= false;
q <= x;
end if;
when false =>
if( stop = '1' ) then
rdy <= true;
end if;
q <= x or q;
end case;
end if;
end process;
ready <= '1' when rdy else '0';

v <= q;
end arch2;
Examen final
17 décembre 2007, 13h30-16h00
Durée: 2h30.
Pondération: 40%.
tion est indiquée.
Faites la conception d’un circuit numérique combinatoire qui accepte en entrée trois nombres signés A, B,
et C exprimés avec W bits et qui a pour sortie la médiane des trois nombres.
Dans une liste de nombres, la médiane est au milieu de la liste classée par ordre de grandeur. Par exemple,
la médiane de {10, -1, 7} est 7. La médiane de {15, 12, 12} est 12.
Vous pouvez utiliser des opérations logiques et arithmétiques (dont la comparaison), des multiplexeurs,
décodeurs et encodeurs, et toute porte logique. Votre circuit doit être purement combinatoire, il ne doit
pas inclure d’éléments à mémoire.
a. Donnez un diagramme de votre circuit identifiant clairement les entrées, les sorties, les blocs de traite-
ment et leurs interconnexions.
Solution :
Une façon d’aborder le problème consiste à recon- B 0
C 1
naître qu’il y a 6 possibilités pour l’ordre de A, B, A S - 2
C : ABC, ACB, BAC, BCA, CAB et CBA. S>T

A 3
lamediane
A 4
Il y a plusieurs solutions possibles. Au minimum, B T

- 5
C
il faut trois comparaisons, mais on peut imaginer B
6
7
S2
S1
S0
plusieurs autres solutions avec plus de comparai-

sons.
Une autre solution intéressante utilise uniquement A S
trois comparaisons mais cascade leurs résultats, ce
S>T
qui réduit la complexité du multiplexeur montré
ici. Cependant, le circuit montré à droite serait plus C T
rapide.
B S
S>T
Toutes les lignes sont des bus de
C T W bits, sauf les lignes de contrôle
du multiplexeur.
INF3500 – examen final – 17 décembre 2007
b. Donnez une description de votre circuit en VHDL, en composant une architecture pour la déclaration
d’entité suivante.
library IEEE;
entity mediane is
generic (
W : positive := 16 -- nombre de bits des opérandes
);
port (
);
end mediane;
Solution :
Encore une fois, il y a une multitude de solutions architecture arch of mediane is
signal ApgB : std_logic := '0';
acceptables. Celle à droite correspond au dia- signal ApgC : std_logic := '0';
gramme de la partie a. On peut aussi imaginer signal BpgC : std_logic := '0';
d’utiliser un processus avec des conditions if-else. begin
ApgB <= '1' when A > B else '0';
ApgC <= '1' when A > C else '0';
BpgC <= '1' when B > C else '0';
with ApgB & ApgC & BpgC select
lamediane <=
B when "000",
C when "001",
A when "011",
A when "100",
C when "110",
B when "111",
end arch;
Considérez le problème de la vérification d’un circuit combinatoire qui doit rencontrer les spécifications
de la question 1.
Complétez le squelette de banc d’essai suivant en VHDL en incluant une génération algorithmique de
vecteurs de tests ainsi qu’une évaluation automatisée des réponses du circuit. Indiquez clairement dans
quelle partie du code existant votre code doit être placé.
library ieee;
entity medianeTB is
generic (W : INTEGER := 16 );
end medianeTB;
architecture archTB of medianeTB is

component mediane
generic (W : INTEGER := 16 );
port (
A, B, C : in SIGNED(W-1 downto 0);
lamediane : out SIGNED(W-1 downto 0)
);
end component;
signal A : SIGNED(W-1 downto 0);
signal B : SIGNED(W-1 downto 0);
signal C : SIGNED(W-1 downto 0);
signal lamediane : SIGNED(W-1 downto 0);
begin
UUT : mediane generic map (W => W) port map (A, B, C, lamediane);
end archTB;
Il y a plusieurs solutions possibles. La vérification par tableau de valeurs pourrait être acceptable si elle
inclut suffisamment de cas possibles. Il y en a 6 de base, en plus des possibilités où deux des trois valeurs
sont identiques. On imagine donc au moins une trentaine de tests. La vérification exhaustive n’est pas
généralement possible, surtout pour de grandes valeurs de W. Un choix intéressant consiste à utiliser une
génération aléatoire. Il faut prendre garde d’inclure des nombres négatifs.
Pour la vérification automatisée, le banc d’essai doit inclure une façon de vérifier que le résultat produit
par l’unité à vérifier est bien correct. Idéalement, on devrait utiliser une description distincte de celle utili-
sée dans l’unité à vérifier.
-- dans la partie déclarative de l’architecture

function donnemediane(A, B, C: integer) return integer is
begin
if (A >= B and B >= C) or (C >= B and B >= A) then
return B;
elsif (B >= A and A >= C) or (C >= A and A >= B) then
return A;
else
return C;
end if;
end donnemediane;
-- dans l’architecture
process
variable Aint, Bint, Cint : integer := -1;
begin
uniform(seed1, seed2, aleatoire); aleatoire := aleatoire - 0.5;
Aint := integer(floor(aleatoire * real(2 ** W)));
Bint := integer(floor(aleatoire * real(2 ** W)));
Cint := integer(floor(aleatoire * real(2 ** W)));
A <= to_signed(Aint, W); B <= to_signed(Bint, W); C <= to_signed(Cint, W);
wait for 10 ns;
assert donnemediane(Aint, Bint, Cint) = to_integer(lamediane)
report "erreur!" severity failure;
end process;
Une opération communément utilisée en traitement d’image est le calcul de la somme des différences ab-
solues (SDA) entre deux images A et B. Cette somme est une mesure de la similarité entre les deux ima-
ges.
Supposons deux (petites) images de 16 × 16 pixels (256 pixels), entreposées dans deux mémoires distinc-
tes de 256 octets chacune. Chaque octet de chaque mémoire contient l’intensité d’un seul pixel sous la
forme d’un nombre non signé entre 0 et 255 inclusivement. Une version en pseudocode d’un algorithme
permettant de calculer la SDA des images A et B est donné ici :
fini = vrai;
tanque(vrai) {
tantque (go = 0) {
; // attendre
}
adresse = 255;
SDA = 0;
fini = faux;
tant que (adresse >= 0) {
SDA = SDA + abs(A[adresse] – B[adresse]);
adresse = adresse – 1;
}
fini = vrai;
}
Dans le pseudocode, les signaux go et fini sont des signaux de contrôle permettant respectivement de
débuter les calculs et d’indiquer que les calculs sont finis. Ils seraient utilisés pour communiquer avec le
reste du système. La variable SDA pourrait être lue par un processus concurrent quand fini = vrai.
Solution :
mémoireA / /
8 16
adresse / abs D Q
8
SDA
reset
mémoireB /
8
b. Donnez la machine à états du processeur. Identifiez bien chaque état, les actions à prendre dans chaque
état, et les conditions pour les transitions entre les états.
Solution :
reset Go = ‘1’
attente init accumule

fini <= vrai SDA <= 0; adresse <= SDA <= SDA +
255; fini <= faux abs(A[adresse] -
B[adresse]);
adresse <= adresse - 1
adresse = 0
c. Donnez une description de votre processeur en VHDL, en composant une architecture pour la déclara-
tion d’entité suivante.
library IEEE;
entity SDA is
generic (
Npixels : positive := 256 -- nombre de pixels dans chaque image
);
port (
CLK, reset, go : in std_logic;
A, B : in unsigned(7 downto 0); -- bus des données de chaque mémoire
adresse : out unsigned(7 downto 0); -- adresse des pixels
laSDA : out unsigned(15 downto 0);
fini : out std_logic
);
end SDA;
Solution :
architecture arch of SDA is
type type_etat is (attente, init, accumule);
begin
variable adresseInt : integer range 0 to Npixels - 1;
variable SDAInt : unsigned(15 downto 0);
begin
if (rising_edge(CLK)) then
etat <= attente;
else
case etat is
when attente =>
if (go = '1') then
etat <= init;
end if;
when init =>
etat <= accumule;
SDAInt := (others => '0');
adresseInt := Npixels - 1;
when accumule =>
SDAInt := SDAInt + abs(to_integer(A) - to_integer(B));
if (adresseInt = 0) then
etat <= attente;
else
adresseInt := adresseInt - 1;
end if;
when others =>
etat <= attente;
end case;
end if;
end if;
adresse <= to_unsigned(adresseInt, adresse'length);
laSDA <= SDAInt;
end process;
fini <= '1' when etat = attente else '0';
end arch;
Considérez le circuit numérique suivant. Supposez que les bascules ont un temps de préparation de 1 ns,
un temps de maintien de 0.5 ns et un délai de propagation de 2 ns. Les délais des autres composantes sont
indiqués. Négligez les délais des interconnexions. Négligez toute contrainte de synchronisation avec les
entrées A et B et la sortie F.
1 ns
D Q
A
4 ns
CLK 3 ns
A
D Q
D Q
1 ns
B
2 ns 6 ns D
CLK
CLK
B
F
D Q
D Q
C 2 ns
3 ns E
CLK 4 ns
CLK
CLK
déphasage d’horloge
a. (3 points) Identifiez clairement le chemin critique et déterminez la fréquence maximale d’horloge. Sup-
posez qu’il n’y a pas de déphasage d’horloge.
Solution : Le chemin critique va des bascules A ou B à la bascule D en passant par la porte OUX, la porte
OU et la porte ET à 3 entrées. La période minimale est de (2 + 4 + 3 + 6 + 1) = 16 ns, donc la fréquence
maximale est de 62.5 MHz.
b. (3 points) Ajoutez un seul niveau de pipeline. Indiquez clairement le nombre et la position des bascules
ajoutées, et donnez la fréquence maximale d’horloge résultante. Supposez qu’il n’y a pas de déphasage
d’horloge.
Solution : Il faut ajouter 3 bascules. Leur meilleur positionnement est immédiatement après la porte OU,
la porte NON-ET et la porte ETX. Le nouveau chemin critique va des bascules A ou B à la nouvelle bas-
cule après la porte OU, en passant par la porte OUX, et la porte OU. La période minimale est de (2 + 4 +
3 + 1) = 10 ns, donc la fréquence maximale est de 100 MHz.
c. (2 points) Quel est l’effet d’avoir un déphasage d’horloge égal à 1 ns sur le circuit sans pipeline? Peut-
on diminuer la période d’horloge? Si oui, à quelle valeur? Justifiez votre réponse.
Solution : Un déphasage d’horloge de 1 ns permettrait de réduire la période d’horloge à 15 ns, soit le délai
total sur le chemin critique. Pour le chemin allant de la bascule D à la bascule A en passant par
l’inverseur, il n’y a pas de problème parce que le délai est de 3 ns, ce qui est supérieur au temps de main-
tien de la bascule A par 2.5 ns.
Considérez l’extrait de code VHDL suivant. Complétez le chronogramme pour T, U, V et F.

library IEEE;
entity VHDLEstMonAmi is
port (
clk1, clk2, reset : in std_logic;
A: in integer;
F : out integer
);
end VHDLEstMonAmi;
architecture jaimeVHDL of VHDLEstMonAmi is

signal T, U : integer := -5;
begin
process (clk1)
variable V : integer := 3;
begin
if reset = '1' then
T <= 0;
elsif (rising_edge(clk1)) then
T <= T + V;
V := V + 2;
end if;
end process;
process (clk2)
begin
if clk2 = '1' then
U <= 5;
else
U <= A + T;
F <= U;
end if;
end if;
end process;
end jaimeVHDL;
10 ns 20 ns 30 ns 40 ns 50 ns
C LK 1
C LK 2
re s e t
A 10 20 50
Solution :
La variable V ne dépend d’aucun autre signal. Sa valeur initiale est 3, spécifiée lors de sa déclaration. Elle
est mise à jour lors de transitions positives du signal clk1, sauf lors d’un reset où elle conserve sa valeur.
Le signal T dépend de V. Sa valeur initiale est -5, spécifiée lors de sa déclaration. Il est mis à jour lors de
transitions positives du signal clk1. La valeur de V utilisée pour le calcul est celle de la dernière itération
du processus. Lors d’un reset, il prend la valeur 0.
Le signal U dépend de T et de A. Sa valeur initiale est -5, spécifiée lors de sa déclaration. Il est mis à jour
lors de transitions positives du signal clk2, parce que clk2 est dans la liste de sensitivité du processus et
qu’on a ajouté la condition (if clk2 = ‘1’). Attention, le résultat de la synthèse serait différent de celui de
la simulation. Lors d’un reset, il prend la valeur 5.
Le signal F dépend uniquement de U. Sa valeur initiale est -231, parce que son type est integer et qu’on ne
spécifie pas de valeur par défaut. Il est mis à jour lors de transitions positives du signal clk2, parce que
clk2 est dans la liste de sensitivité du processus et qu’on a ajouté la condition (if clk2 = ‘1’). Attention, le
résultat de la synthèse serait différent de celui de la simulation. La valeur assignée à F est celle de U lors
de la dernière exécution du processus.
Considérez le processeur à usage général décrit dans les notes de cours, sections 8.6 à 8.8 inclusivement.
Ajoutez une instruction de la forme Rk #WXYZ, permettant de charger le registre k avec une valeur
immédiate de 16 bits de large (WXYZ représente 4 chiffres hexadécimaux). Cette instruction nécessite
deux mots de 16 bits dans la séquence des instructions : le premier représente l’instruction (chargement de
valeur immédiate de 16 bits) et le deuxième contient la valeur WXYZ.
a. Donnez le diagramme d’état modifié du processeur (figure 8-17 des notes de cours) pour supporter cet-
te nouvelle instruction. Il n’est pas nécessaire de reproduire le diagramme d’états au complet, il faut seu-
lement indiquer le(s) nouvel(eaux) état(s), sa(leur) relation(s) avec les états existants, et les actions à
prendre dans cet(ces) état(s).
Solution :
Un seul état supplémentaire suffit. En arrivant dans cet état, le PC pointe à la valeur de 16 bits qui doit
être chargée dans le registre. Il est donc essentiel d’incrémenter le PC à nouveau pour le faire pointer à la
prochaine instruction, qui sera chargée dans l’état quérir.
type = chargeImm16
chargeimm
quérir décoder
IR <= MI[PC]
16
PC <= PC + 1 PC <= PC + 1
b. Donnez l’encodage de votre nouvelle instruction (tableau 8-5 des notes de cours).
Solution : une possibilité est 1010 | destination | - | -
où destination indique le registre à charger (0 à 15), et les ‘-‘ indiquent des valeurs sans importance.
c. Donnez la nouvelle ligne de code pour le signal choixSource (exemple 8-14 des notes de cours).
Solution :
with etat select choixSource <= 0 when opUAL, 1 when chargeImm16, 3 when others;
d. Donnez la nouvelle ligne de code pour le signal constante (figure 8-12 et exemple 8-11 des notes
de cours)
Solution :
constante <= signed(memoireInstructions(PC));
Examen intra
er
1 novembre 2007
Durée: 2h.
Pondération: 20%.
tion est indiquée.
Considérez l’extrait de code VHDL suivant. Donnez son équivalent en matériel à l’aide d’un schéma de
portes logiques.
library ieee;
entity monModule is
port (
A : in std_logic;
B : in std_logic;
C : in std_logic;
F : out std_logic;
G : out std_logic;
H : out std_logic
);
end monModule;
architecture arch of monModule is

begin
F <= not(A and (B xor not(C)));
G <= '0' when (A = '1' or B /= C) else '1';
with A select H <= B when '0', C when others;
end arch;
Solution :
Faites la conception d’un circuit numérique combinatoire qui accepte en entrée un nombre non-signé ex-
primé avec 8 bits ainsi qu’un facteur non-signé exprimé avec 4 bits. La sortie doit être un produit de 12
bits du nombre et de son facteur. Utilisez uniquement les opérations d’addition, soustraction et décalage.
Votre circuit doit être purement combinatoire, il ne doit pas inclure d’éléments à mémoire.
a. Donnez un diagramme de votre circuit (3 points)
Solution :
b. Donnez sa description en VHDL (3 points)

Solution :
library IEEE;
entity controleMultiplicateur is
port (
facteur : in unsigned(3 downto 0);
produit : out unsigned(11 downto 0)
);
end controleMultiplicateur;
architecture arch of controleMultiplicateur is

signal add0, add1, add2, add3 : unsigned(11 downto 0);
begin
add0 <= "0000" & nombre when facteur(0) = '1' else (others => '0');
produit <= (add3 + add2) + (add1 + add0);
end arch;
use IEEE.std_logic_1164.all; use IEEE.std_logic_1164.all;
entity module1 is entity module1TB is
port ( end module1TB;
A, B : in std_logic; architecture arch of module1TB is
F : out std_logic component module1
); port (
end module1; A, B : in std_logic;
architecture arch of module1 is F : out std_logic
signal S1, S2: std_logic; );
begin end component;
S1 <= A and B; signal A,B,F : std_logic;
S2 <= not(B); begin
process (S1, S2) UUT : module1 port map (A, B, F);
begin A <= '0' after 0 ns;
F <= S1 xor S2; B <= '1' after 0 ns, '0' after 10 ns;
end process; end arch;
end arch;
a. Donnez la liste des événements à partir du temps de simulation 10 ns, telle qu’elle pourrait être dressée
par un simulateur qui exécuterait le banc d’essai. (2 points)
Solution :
énoncé temps
B <= ‘0’ 10 ns
S1 <= A and B 10 ns + ∆
S2 <= not(B) 10 ns + ∆
F <= S1 xor S2 10 ns + 2∆
b. En vous basant sur votre liste des événements, donnez un chronogramme à partir du temps de simula-
tion 10 ns, montrant la valeur des signaux internes et de sortie en tenant compte des délais deltas. (2
points)
Solution :
Considérez le problème des feux de circulation à l’intersection d’une route secondaire et d’une route prin-
cipale. Le feu doit débuter vert sur la route principale, sauf quand un senseur sous la chaussée de la route
secondaire détecte la présence d’une voiture. Le feu de la route principale doit alors passer au jaune pour
une seconde, puis au rouge pour 30 secondes. Le feu de la route secondaire doit être vert pendant ces tren-
te secondes, puis passer au jaune pendant une seconde, puis passer au rouge. Le feu doit alors être vert sur
la route principale jusqu’à ce que le senseur soit activé de nouveau.
a. Donner un diagramme d’états pour ce système. Ne pas indiquer la valeur des sorties (les signaux de
contrôle des feux) sur le diagramme. (2 points)
Solution :
b. Considérez la déclaration d’entité suivante en VHDL. Donnez une architecture pour cette entité qui
respecte les spécifications du problème. Supposez que le signal clk est une horloge de 1 Hz, et que le
signal reset est utilisé lors de la maintenance du système pour le réinitialiser. (4 points)
library IEEE;
entity feuxcirculation is
port(
clk, reset, senseur : in std_logic;
-- feux rouge, jaune et vert, pour chacune des deux routes:
feuxPrincipale : out std_logic_vector(2 downto 0);
feuxSecondaire : out std_logic_vector(2 downto 0)
);
end feuxcirculation;
Solution :
architecture arch of feuxcirculation is
type type_etat is (VP, JP, VS, JS);

signal etat : type_etat := VP;
-- durée du feu vert sur la route secondaire, en périodes d'horloge

constant dureeVertSecondaire : integer := 30;
begin
variable compteur : integer range 0 to dureeVertSecondaire;
begin
etat <= VP;
else
case etat is
when VP =>
if (senseur = '1') then
etat <= JP;
end if;
when JP =>
etat <= VS;
compteur := dureeVertSecondaire;
when VS =>
compteur := compteur - 1;
if (compteur = 0) then
etat <= JS;
end if;
when JS =>
etat <= VP;
end case;
end if;
end if;
end process;
process(etat)
begin
case etat is
when VP =>
feuxPrincipale <= "001";
feuxSecondaire <= "100";
when JP =>
when VS =>
when JS =>
end case;
end process;
end arch;
Considérez le circuit d’un additionneur à trois bits montré ici comme module de base.
En utilisant une seule instance de ce module, donnez un circuit séquentiel qui permet d’additionner des
paires de nombres de n bits présentés de façon sérielle.
Solution :

École Polytechnique de Montréal Page 1/12 Département de Génie Informatique Et Génie Logiciel

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

École Polytechnique de Montréal Page 1/12 Département de Génie Informatique Et Génie Logiciel

Transféré par

Droits d'auteur :

Formats disponibles

INF3500 : Conception et réalisation de systèmes numériques

b. Donnez sa description en VHDL.

architecture arch of finalMultiplicateur is

b. Donnez la machine à états du processeur.

c. Donnez une description VHDL du processeur.

b. Donnez la machine à états du processeur.

c. Donnez une description VHDL de l’architecture du processeur correspondant à l’entité suivante.

La période correspondante à 50 MHz est 20 ns.

a. Considérez le système d’équations logiques suivant :

architecture arch of monModule is

INF3500 – examen final – 15 août 2007

Les codes d'

architecture arch of securite is

carte1 := (A = '0' and B = '1');

code1 := (code = "101" or code = "110");

if (carte1 and code1) then

if (carte2 and code2) then

if ( carteNV or (carte1 and not(code1)) or (carte2 and not(code2)) ) then

architecture arch of multipleDeSeptTB is

signal I : unsigned(5 downto 0);

-- votre code ici

Considérez le modèle VHDL suivant. Donnez le diagramme d’états correspondant.

architecture arch of controleQ5 is

elsif x = "01" then

x=01 x=11 x=10

Exemple : addition 7 + 8 en BCD :

Exemple : addition 9 + 8 en BCD :

architecture tbexhaustive1 of addbcdTB is

-- vous pouvez ajouter du code ici si nécessaire ...

UUT : addbcd port map (oper1, oper2, somme, cout);

-- vous pouvez ajouter du code ici si nécessaire ...

signal oper1, oper2, somme : UNSIGNED(3 downto 0);

UUT : addbcd port map (oper1, oper2, somme, cout);

wait for 10 ns;

if cout = '1' then

assert lasomme = k1 + k2 report "erreur!" severity failure;

report "simulation terminée!" severity failure;

-- code tiré de S. Brown & Z. Vranesic,

ARCHITECTURE Behavior OF arbiter IS

(tiré de S. Brown & Z. Vranesic, Fundamentals of Digital Logic, McGraw-Hill, 2005.)

type memoire is array (0 to N - 1) of std_logic_vector(W - 1 downto 0);

if (wr_en = '1') then

architecture comportementale of majorite is

if (compte > W / 2) then

entity sim is entity simTB is

Représentation Représentation en virgule flottante

a. Donnez un diagramme de votre circuit.

b. Donnez sa description en VHDL.

architecture arch1 of vfixeavflottante is

Concevez un processeur qui effectue la traduction d’adresses dans un routeur. La traduction

La Figure 1 illustre un cas de correspondance entre plusieurs adresses. L’adresse IP 0 (0.0.0.0)

Figure 1. Exemple de correspondance entre deux tables.

En bref, le circuit fonctionnera comme suit :

La Figure 2 précise les interfaces du circuit NAT.

Les interfaces se décrivent comme suit :

generic (tab_size : integer := 10);

port (rst_n : in std_logic;

architecture beh of nat is

unite_controle : process (clk, rst_n)

begin -- process unite_controle

-- activities triggered by rising edge of clock

-- lecture et multiplexage de l'IP lu selon le type de l'adresse a lire

-- mise a jour des signaux de controle et de sortie selon l'etat courant