Chap3 - SoC - M1 SIIoT

06/11/2023
Chapitre 3
Synthèse VHDL
Année Universitaire 2023-2024
1. Introduction
Présentation générale du VHDL
 VHDL ≡ VHSIC Hardware Description Language
VHSIC : Very High Speed Integrated Circuit ( programme de la défense des
USA datant des années 80 visant à développer des circuits intégrés)
 Le VHDL permet la programmation des circuits logiques pragrammables

(Exemple: FPGA).
 C’est un langage de haut niveau adapté à la description fonctionnelle de

systèmes complexes.
 Le VHDL est un langage de test permettant la validation d’un composant aux

différents stades de son développement (cycle en V).
 Concurents : verilog HDL et systemC.
 Outils logiciels : modelSim, Quartus II (Intel), ISE et vivado (Xilinx)

M. FEKI – Architecture des SoCs 2
1
06/11/2023
1. Introduction
Flot de conception
Banc de test
Description VHDL (testbench)
Spécification Entity sys is
(fonction du port (A,B: in std_logic;
fichier.vhd
Générer un code
circuit) S: out std_logic ); Compilation VHDL destiné à la Simulation Chronogrammes
End system; vérification par
(vérification des testbench.vhd
Architecture Arch of sys is simulation le bon
Begin erreurs de syntaxe) fonctionnement
S<= A and B; du système (lui-
……. même en vhdl)
End arch;
Synthèse et implémentation
Synthèse Placement et routage Génération du bitsream
0100001010100101
netlist 1010101010001000
0111010100101101
0111000011111001 Fichier binaire
0110101001011011
1110101000100100
1110011110000000
1111010000111100
3
2. Structure d’une description VHDL

Exemple de démarrage
 Une description VHDL est composée de deux parties:
- L’entité (ENTITY) qui définit les E/S.
- L’architecture (ARCHITECTURE) qui contient les instructions VHDL
permettant de décrire le fonctionnement du système.
 Exemple : Additionneur 1 bit (demi-additionneur)
Table de vérité : A S
A B S R B R
0 0 0 0
0 1 1 0 A
S
1 0 1 0 B
1 1 0 1 R
2
06/11/2023

Exemple de démarrage
-- ceci est un commentaire

-- déclaration des librairies et des packages
Library ieee;
use ieee.std_logic_1164.all; Remarques:
-- déclaration de l’entité -Aucune distinction entre les
ENTITY additionneur IS miniscules et les majuscules
PORT(
A,B: in std_logic; - En général, les instructions
S,R: out std_logic); se terminent par ;
END additionneur;
-- déclaration de l’architecture
ARCHITECTURE arch OF additionneur IS
BEGIN
S <= A XOR B;
R <= A AND B;
END arch;

Déclaration des bibliothèques et des packages
 Bibliothèque de base (utilisée pour n’importe quelle description VHDL)
Library ieee; -- la bibliothèque ieee

Use ieee.std_logic_1164.all; -- package contenant
-- les différents types des
-- signaux (bit, entier..
 Pour réaliser certaines opérations (exemple : opérations signés ou non signés,

conversion de type..), il faut faire appel à des packages supplémentaires.
use ieee.std_logic_arith.all;
use ieee.numeric_std.all;
use ieee.std_logic_unsigned.all;
3
06/11/2023

Déclaration de l’entité
ENTITY <nom de l’entité> IS

PORT(
<nom signal_1>:<sens signal_1> <type signal_1>;
⁞
<nom signal_n>:<sens signal_n> <type signal-n>
);
END <nom de l’entité> ;
Remarque:
On ne met pas de ; après la
 Sens du signal : définition du dernier signal
- in signal d’entrée
- out signal de sortie
- inout signal d’entrée/sortie
- buffer signal de sortie réentrant

 Type du signal :
- bit ‘0’ ou ‘1’
- std_logic ‘0’ ou ‘L’ niveau bas

‘1’ ou ‘H’ niveau haut
‘x’ ou ‘-’ valeur quelconque (‘0’ ou ‘1’)
‘Z’ haute impédance (non commandé)
- integer (entier)
integer range <low> to <hight> (entier défini dans un intervalle)
- std_logic_vector ((n-1) downto 0) (vecteur de n bits)
 Exemple : un bus d’entrée de 4 bits

Bus : in std_logic_vector (3 downto 0);
4
06/11/2023

 Paramètre Générique : Dans l’entité, l’utilisation du mot GENERIC permet
d’annoncer la liste des paramètres variables du composant. Par exemple, le
paramètre générique peut être (le modulo d’un compteur variable) ou la taille
d’un vecteur (vecteur à taille variable). L’intérêt de ce type de paramètre est
l’adaptabilité et la facilité de réutilisation.

GENERIC(
<Paramètre_1> : <type> [:=<valeur par défaut>];
⁞
<Paramètre_n> : <type> [:=<valeur par défaut>] );
PORT(
⁞
);
END <nom de l’entité>
Remarque : L’affectation d’une valeur par défaut est facultatif.


Déclaration de l’architecture
ARCHITECTURE <nom de l’architecture> OF <nom de l’entité> IS

<déclarations des signaux internes et des constantes>;
BEGIN
<instruction 1>;
⁞
<instruction n>;
END <nom de l’architecture> ;
 Déclaration d’un signal interne

SIGNAL <nom signal> : <type signal>;
 Déclaration d’une constante

CONSTANT <nom constante> : <type constante> := <valeur> ;
Une constante prend sa valeur au

moment de la déclaration
5
06/11/2023

Déclaration de l’architecture
 Déclaration d’autres types de données : en plus des types de signaux prédéfinis
(std_logic, integer, std_logic_vector,…) On peut déclarer d’autres types de signaux
(avant BEGIN de l’architecture).
Déclaration:
TYPE <nom type> IS (caractere_1,…, caractere_n);
Instanciation:
SIGNAL <nom signal> : <nom type>;
Exemple :
TYPE couleur IS (bleu, jaune, rouge);--déclaration du premier
--type
TYPE Etat IS (init, debut, fin); --déclaration du second type
SIGNAL C1 : couleur; --instanciation type 1
SIGNAL E : Etat; --instanciation type 2
3. Les opérateurs
L’affectation simple <=
R <= A and B;
R <= A and B after 10ns; -- affectation retardée de
10ns
 Les bases numériques utilisées pour un bus peuvent être :
Bus <= “1001” ; --bus = 9 en décimal

Bus <= x“9”; --bus = 9 en hexadécimal
Bus <= O“11”; --bus = 9 en octale
6
06/11/2023
3. Les opérateurs
La concaténation &
 Elle permet de joindre des signaux entre eux.
 Exemple : Soit A et B de type vecteur de 3 bits et S de type vecteur de 8

bits A=“001” et B=“110”
S <= A & B & “01” ; --S prend la valeur suivante

--S= “001 110 01”
Valeur de A Valeur de B
3. Les opérateurs
Les opérateurs logiques
Opérateur VHDL
ET and
Non ET nand
OU or
Non OU nor
OU exclusif xor
non not
Décalage à gauche sll
Décalage à droite srl
Peu utilisés
Rotation à gauche rol
Rotation à droite ror
7
06/11/2023
3. Les opérateurs
 Pour réaliser des décalages et des rotations logiques, il est préférable

d’utiliser la concaténation (qui permet d’expliciter l’opération réalisée)
 Décalage à droite
A<=“01011111” ; --A est un std_logic_vector(7 downto 0)

S<=‘0’& A(7 downto 1); --décalage d’un bit à droite
--S=“00101111”
S<=“000” & A(7 downto 3); --décalage de 3 bits à droite
--S=“00001011”
 Décalage à gauche
S<= A(6 downto 0) & ‘0’; --décalage d’un bit à gauche

--S=“10111110”
S<= A(4 downto 0)& “000”; --décalage de 3 bits à gauche
--S=“11111000”
3. Les opérateurs
 Rotation à gauche
A<=“01011111” ;
S<= A(6 downto 0) & A(7); --rotation d’une position à
--gauche S=“10111110”
 Rotation à droite
S<= A(2 downto 0) & A(7downto 3); --rotation de 3 bits à

-- droite S=“11101011”
8
06/11/2023
3. Les opérateurs
Les opérateurs arithmétiques
Opérateur VHDL
Addition +
Soustraction -
Multiplication *
Division /
 Pour pouvoir utiliser les opérateurs arithmétiques, il faut rajouter la

bibliothèque suivante:
3. Les opérateurs
Les opérateurs relationnels
Opérateur VHDL
Egal =
Non Egal /=
Inférieur <
Inférieur ou Egal <=
Supérieur >
Supérieur ou Egal >=
9
06/11/2023
4. Les instructions concurrentes

Affectation conditionnelle
Les instructions concurrentes sont exécutées simultanément. L’ordre des

instructions dans le code source n’a pas d’influence.
<signal> <= <expression 1> WHEN <condition1> ELSE

<expression 2> WHEN <condition2> ELSE
⁞
ELSE <expression n>;--cette instruction permet de
--définir la valeur du signal
--dans le cas où aucune
--condition n’est remplie

 Exemple : Mux 4  1
4 S <= E1 WHEN SEL= "00" ELSE

E1 E2 WHEN SEL= "01" ELSE
4
E2 4 E3 WHEN SEL= "10" ELSE
4 S
E3 E4 WHEN SEL= "11"
4
E4 2 ELSE "ZZZZ";
SEL
10
06/11/2023

Affectation sélective
WITH <signal de selection> SELECT

<signal> <= <expression 1> WHEN <valeur 1 de selection>,
⁞
<expression n> WHEN <valeur n de selection>,
<expression> WHEN OTHERS;
 Exemple : Mux 4  1
WITH SEL SELECT
S <= E1 WHEN "00",
E2 WHEN "01",
E3 WHEN "10",
E4 WHEN "11",
"ZZZZ" WHEN OTHERS;

Instructions GENERATE
L’instruction GENERATE permet de créer des structures répétitives et

conditionnelles.
 Structure répétitive
<nom structure>:FOR <var> IN <val_debut> TO <val_fin> GENERATE
<instructions concurrentes>;
END GENERATE <nom structure>;
 Structure conditionnelle
<nom structure>:IF <condition> GENERATE
<instructions concurrentes>;
END GENERATE <nom structure>;
 Remarques:
- <nom structure>: est obligatoire,
- La variable <var> ne se déclare pas.
11
06/11/2023
5. Les instructions séquentielles

Notion de PROCESS
 Les instructions sont exécutées d’une manière séquentielle l’une après l’autre.
L’ordre des instructions est donc important. Les instructions séquentielles sont
déclarées dans un process.
 Un process est une partie de la description d’un circuit dans laquelle les
instructions sont exécutées séquentiellement c-à-d les une à la suite des autres.
[nom process:]PROCESS(liste de sensibilité)

VARIABLE <nom_var> : <type_var> := <valeur>;
BEGIN
<instructions séquentielles>;
END PROCESS [nom process]; Le process se déclenche dès
qu’un signal dans la liste de
sensibilité change d’état.
 Remarques:
- [nom process:] est facultatif,
- Une variable est déclarée uniquement dans un process.

PROCESS(liste de sensibilité)
BEGIN
IF <condition 1> THEN
ELSIF <condition 2> THEN
ELSE <instructions séquentielles>;
END IF;
END PROCESS;
 Exemple: Décodeur de parité (P prend 1 si un nombre impaire est détecté)
PROCESS(D)
BEGIN Décodeur P
D
IF D(0)=‘1’ THEN P<=‘1’; 8 de parité
ELSE P<=‘0’;
END IF;
END PROCESS; M. FEKI – Architecture des SoCs 24
12
06/11/2023

Affectation sélective
BEGIN
CASE <signal de selection> IS
WHEN <val_1 de selection> => <instructions>;
⁞
WHEN <val_n de selection> => <instructions>;
WHEN OTHERS => <instructions>;
END CASE;
END PROCESS;
 Remarque: ne pas confondre implication => et affectation <=
 Exemple : Décodeur de parité PROCESS(D)

BEGIN
CASE D(0) is
WHEN ‘1’ =>P<=‘1’;
WHEN OTHERS =>P<=‘0’;
END CASE;
M. FEKI – Architecture des SoCs END PROCESS; 25

Boucle FOR .. LOOP
BEGIN
[nom boucle:] FOR <var> IN <val_debut> TO <val_fin> LOOP
END LOOP [nom boucle];
END PROCESS;
 Remarques:
- [nom boucle:] est facultatif,
- Il ne faut pas déclarer la variable utilisée.
 Exemple : Porte OR bit par bit

a OR
PROCESS(a,b) 4 S
BEGIN bit par bit 4
b
FOR i IN 0 TO 3 LOOP 4
S(i)<=a(i) or b(i);
END LOOP;
END PROCESS; M. FEKI – Architecture des SoCs 26
13
06/11/2023

Boucle WHILE .. LOOP
BEGIN
[nom boucle:] WHILE <condition> LOOP
END LOOP [nom boucle];
END PROCESS;
 Remarque: [nom boucle:] est facultatif.

Boucle WHILE .. LOOP
 Exemple : Porte OR bit par bit
PROCESS(a,b)
VARIABLE i : integer; --il faut déclarer la variable i
BEGIN
i:=3;
WHILE i>=0 LOOP
S(i)<=a(i) or b(i);
i:=i-1; --il faut décrémenter i
END LOOP;
END PROCESS;
14
06/11/2023
6. Types d’architectures
Vue d’ensemble
 Architecture flot de données
 Architecture comportementale
 Architecture structurelle
Architecture flot de données
C’est une architecture dans laquelle on utilise les équations logiques c-à-d qui
utilise toute sorte d’opérateurs (affectation simple, concaténation, opérateurs
logiques, opérateurs arithmétiques et opérateurs relationnels) ainsi que des
instructions concurrentes (WHEN…ELSE ; WITH…SELECT et GENRATE). Ainsi dans
ce type d’architecture, les instructions sont exécutées simultanément (l’ordre
de déclaration n’a pas d’influence). Cette architecture est utilisée pour les petits
circuits.
15
06/11/2023
 Exemple : Additionneur complet 1 bit A B Rin S Rout

0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
Donner la description VHDL du circuit 1 1 0 0 1
avec une architecture flot de données. 1 1 1 1 1
 Exemple : Additionneur complet 1 bit
S =ABRin+ ABRin+ ABRin+ ABRin
= (AB+AB)Rin+Rin(AB+AB)
= (A xor B)Rin+Rin(A xnor B)
= S1 Rin + Rin S1
= S1 xor Rin
16
06/11/2023
Rout = ABRin+ ABRin+ ABRin+ ABRin

A S1
= Rin(AB+AB) + AB(Rin+Rin) B S
Rin
= Rin S1 + (A and B) S2
= (Rin and S1) + S3 S3 Rout
= S2 + S3
Library ieee; Solution qui utilise les
use ieee.std_logic_1164.all; calculs logiques
ENTITY Add_complet IS
PORT(
A,B,Rin: in std_logic;
S,Rout: out std_logic);
END Add_complet;
ARCHITECTURE flot_donnees OF Add_complet IS
SIGNAL S1,S2,S3:std_logic; --S1,S2 et S3 des signaux internes
BEGIN
S <= S1 xor Rin; -- l’ordre n’a pas d’influence
Rout <= S2 or S3;
S1 <= A xor B;
S2 <= S1 and Rin;
S3 <= A and B;
END flot_donnees;
17
06/11/2023
Solution qui utilise

Library ieee; directement la table de
use ieee.std_logic_1164.all; vérité
ENTITY Add_complet IS
PORT(
A,B,Rin: in std_logic;
S,Rout: out std_logic);
END Add_complet;
ARCHITECTURE flot_donnees OF Add_complet IS
Signal Sin: std_logic_vector(2 downto 0);
Signal Sout : std_logic_vector(1 downto 0);
BEGIN
Sin<=A&B&Rin;
Solution qui utilise

WITH Sin SELECT directement la table de
Sout<="00" WHEN "000", vérité
"10" WHEN "001",
"10" WHEN "010",
"01" WHEN "011",
"10" WHEN "100",
"01" WHEN "101",
"01" WHEN "110",
"11" WHEN OTHERS ;
S<=Sout(1);
Rout<=Sout(0);
END flot_donnees;
18
06/11/2023
Architecture comportementale
C’est une architecture dans laquelle on fait appel à un process qui permet
l’exécution séquentielle des instructions (l’une après l’autre) et par conséquent on
peut faire appel aux instructions IF…THEN, CASE…IS….WHEN, FOR…LOOP et
WHILE…LOOP. Cette architecture est utilisée pour les circuits de toutes les tailles.
 Exemple : Description d’une bascule D

NB: syntaxe relatif au signal d’horloge CLK
Front montant CLK’event and CLK=‘1’

ou rising_edge(CLK)
D S
Front descendant CLK’event and CLK=‘0’
ou falling_edge(clk) CLK
Niveau haut CLK=‘1’

Niveau bas CLK=‘0’M. FEKI – Architecture des SoCs
37
Architecture comportementale
Library ieee;
use ieee.std_logic_1164.all;
ENTITY bascule IS
PORT(
D,CLK: in std_logic;
S: out std_logic);
END bascule;
ARCHITECTURE Arch OF bascule IS
BEGIN
PROCESS(CLK) --la liste de sensibilité = clk uniquement
BEGIN
IF CLK’event and CLK=‘1’ THEN --ou rising_edge(clk)
S<=D;
END IF;
END PROCESS;
END Arch;
19
06/11/2023
Architecture structurelle
C’est une architecture qui permet de décrire le circuit sous forme de composants
interconnectés. Cette architecture est adaptée à des circuits de taille moyenne à
grande.
--Déclaration de l’entité
PORT(
⁞
);
END <nom de l’entité> ;
--Déclaration de l’architecture
ARCHITECTURE <nom de l’architecture> OF <nom de l’entité> IS
<déclarations des signaux internes et des constantes>;
--Déclaration des composants

COMPONENT <nom composant_1>
PORT(
<déclaration des E/S du composant> --la dernière ligne
--ne prend pas de ;
);
END COMPONENT;
COMPONENT <nom composant_n>

PORT(
<déclaration des E/S du composant>
);
END COMPONENT;
20
06/11/2023
BEGIN
--Instantation des composants
<label comp_1> : <nom comp_1> PORT MAP(instanciation des E/S);
⁞
<label comp_n> : <nom comp_n> PORT MAP(instanciation des E/S);
--L’instanciation des E/S se fait dans l’ordre où elles
--étaient déclarées dans le composant
END <nom de l’architecture>;
 Un paramètre générique peut être utilisé dans un composant comme suit:

--Déclaration du composant
COMPONENT <nom composant>
GENERIC(
<Paramètre_1> : <type> [:=<valeur par défaut>];
⁞
<Paramètre_n> : <type> [:=<valeur par défaut>];
);
PORT(
<déclaration des E/S du composant>;
);
END COMPONENT;
……
--Instanciation du composant
<label_comp> : <nom_comp> GENERIC MAP(<valeurs paramètres
génériques>) PORT MAP(instanciation des E/S);
21
06/11/2023
 Exemple : Système de gestion de parking
CaptE CE
Comparateur
CaptS CS Compteur/ NP S_NP
NPO B CB
Décompteur
H Clk
1. Donner la description comportementale du compteur/décompteur qui permet

de déterminer le nombre de voitures garées dans le parking. On suppose que les
traitements sont actifs au front montant d’horloge. Il possède comme entrées un
signal d'horloge (clk), un signal provenant d'un capteur d'entrée (CE) qui sert à
incrémenter le compteur et un signal provenant d'un capteur de sortie (CS) qui
sert à décrémenter le compteur.
Si une voiture entre dans le parking (CE = 1) alors on incrémente le compteur et

si une voiture sort du parking (CS = 1) alors on décrémente le compteur. Le
nombre de voitures garées dans le parking (NP) représente la sortie du
compteur/décompteur (entier).
2. Donner la description flot de données du comparateur qui possède comme

entrée le nombre de places occupées dans le parking (NPO) et la commande de
barrière (B) comme sortie. Ce circuit permet de comparer le nombre de places
occupées NPO avec N qui est un paramètre générique initialisé à 100 et qui
représente le nombre de places disponibles dans le parking. S’il existe des
places non occupées alors on ouvre la barrière d’entrée (B=1) sinon la barrière
reste fermée.
3. Ecrire la description VHDL du circuit de commande.
22
06/11/2023
1.
Library ieee;
ENTITY ComptDecompt IS
PORT(
CE,CS, Clk : in std_logic;
NP : out integer);
END ComptDecompt;
ARCHITECTURE Arch OF ComptDecompt IS
SIGNAL S: integer :=0;
BEGIN
PROCESS(CLK)
BEGIN
IF (CLK’event and CLK=‘1’) THEN
IF CE=‘1’ THEN
S<=S+1;
ELSIF CS=‘1’ THEN

S<=S-1;
ElSE
S<=S; -- facultatif
END IF;
END IF;
END PROCESS;
NP<=S;
END Arch;
23
06/11/2023
2.
Library ieee;
ENTITY Comparateur IS
GENERIC( N: integer := 100);
PORT(
NPO: in integer;
B : out std_logic);
END Comparateur;
ARCHITECTURE Arch OF Comparateur IS
BEGIN
B<=‘1’ when NPO<N else ‘0’;
END Arch;
3.
Library ieee;
ENTITY SystemeGP IS
PORT(
CaptE, CaptS, H: in std_logic;
CB: out std_logic);
END SystemeGP ;
ARCHITECTURE Arch OF SystemeGP IS
Signal S_NP : integer;
COMPONENT ComptDecompt
PORT(
CE,CS, Clk : in std_logic;
NP : out integer);
END Component;
24
06/11/2023
COMPONENT Comparateur
PORT(
NOP: in integer;
B : out std_logic);
END COMPONENT;
BEGIN
SS1: ComptDecompt PORT MAP(CE => CaptE,
CS => CaptS,
Clk => H,
NP => S_NP);
SS2: Comparateur GENERIC MAP(100) PORT MAP(NOP => S_NP,
B => CB);
END Arch;
7. Le banc de test (test bench)

Présentation et étapes à suivre
 Pour faire la simulation d’une description VHDL, il faut écrire un autre
programme VHDL appelé testbench. Le testbench permet de définir les stimulus à
appliquer au circuit.
 Etapes à suivre pour écrire un test bench

1. Ecrire les bibliothèques et les packages nécessaires
2. Ecrire une entité vide
3. Déclarer le circuit à simuler comme étant un composant dans l’architecture
(avant BEGIN de l’architecture)
4. Déclarer des signaux internes et éventuellement des constantes : définir un
signal interne pour chaque entrée ou sortie du circuit (avant BEGIN de
l’architecture)
5. Dans le corps de l’architecture, instancier le composant (le circuit à simuler) en
associant les signaux internes déclarés à l’entrée/sortie correspondante.
6. Ecrire un process pour chaque stimuli qui varie dans le temps, aucune liste de
sensibilité n’est associée à ce process.
25
06/11/2023

Exemple
 Exemple : le test bench pour simuler le fonctionnement d’une bascule D
(voir diapo 37)
Library ieee;
ENTITY bench IS
END bench;
ARCHITECTURE Arch OF bench IS
SIGNAL D_b, Clk_b, S_b: std_logic;
CONSTANT T: time :=2 ns;
COMPONENT bascule IS
PORT(
D,CLK: in std_logic;
S: out std_logic);
END COMPONENT;
BEGIN
U:bascule PORT MAP (D => D_b, CLK => clk_b, S=>S_b);

Exemple
P_clk : PROCESS
BEGIN
clk_b<=‘0’;
WAIT for T/2;
clk_b<=‘1’;
WAIT for T/2;
END PROCESS P_clk;
P_D : PROCESS
BEGIN
D_b<=‘0’;
WAIT for 3*T;
D_b<=‘1’;
WAIT for 2*T;
D_b<=‘0’;
WAIT;
END PROCESS P_D;
END Arch;
26
06/11/2023
8. Description des machines à états finis

Systèmes séquentiels : rappel
 On considère un système à une entrée E et une sortie S.
 Pour une même valeur de E, S peut prendre deux valeurs 0 ou 1. Ce

système n'est pas combinatoire car on ne peut pas définir S = f(E).
 La valeur de S peut être déterminée en utilisant ce qui s'est passé

auparavant (l’état interne Q).
M. FEKI – Architecture des SoCs 53 53

 Il s’agit alors d’un système séquentiel dont la sortie S dépend de l’entrée

E et de l’état interne Q: S=f(E, Q).
 Système séquentiel:
Entrées Circuit Sorties
Combinatoire
Etat Etat
présent futur
Mémoire
 Un système séquentiel comprend une mémoire (bascules, registre..)

pour stocker l’état interne.
27
06/11/2023

 Machine à états finis (Finite State Machine : FSM)
 Tout système séquentiel synchrone peut être décrit à l’aide d’une

machine à états finis.
 Dans la pratique, les machines à états permettent de décrire des

systèmes séquentiels dont l’évolution est plus complexe que les
compteurs ou les registres comme les séquenceurs ou les blocs de
contrôle (qui commande les parties opératives (ALU, accumulateur
etc.))

Partie
opérative
28
06/11/2023

Architectures Moore & Mealy
Horloge
Etat
Entrées Sorties
Fonction futur Fonction
p combinatoire Registre n
combinatoire q
n
d’état
Calcul de présent Calcul de
l’état futur sortie
Etat présent
Mealy
 Architecture de Moore : la liaison en pointillé n’existe pas.

 Architecure de Mealy : la liaison en pointillé est présente.

Horloge
Etat
Entrées Sorties
p combinatoire Registre n
combinatoire q
n
d’état
Calcul de présent Calcul de
Etat présent
Mealy
 Machine de Moore : les sorties ne dépendent que de l’état interne

présent : S=f(Q).
 Architecure de Mealy : les sorties dépendent de l’état interne présent
et des entrées : S=f(E,Q).
29
06/11/2023

 Machine de Moore : les sorties changent en réponse au changement

d’état de la machine donc au front d’horloge vu que le changement de
l’état est synchronisé par l’horloge.
 Machine de Mealy : les sorties peuvent changer directement en

réponse au changement des entrées, même entre 2 fronts d’horloge
=> sortie asynchrone.
 Pour un même système, une machine de Moore demande plus d’états

que la machine de Mealy équivalente.

Règles de construction du diagramme à états
 Un diagramme ou graphe d’états est une représentation graphique de

la machine à états finis.
 Il est constitué par l’énumération de tous les états possibles du système
(dont le nombre est fini).
 Un seul de ces états peut être actif à la fois.
 L’état est représenté par un cercle. Le nom rattaché à l’état est noté à
l’intérieur du cercle.
Nom de l’état
Etat 1
30
06/11/2023

 La transition entre deux états est représentée par un arc fléché. La

condition enclenchant cette transition (condition de réalisation sur les
entrées) est notée sur l’arc.
Condition de transition
E=1
Etat 1 Etat 2
 Pour qu'une transition soit activée, il faut que les 3 conditions

suivantes soient réalisées :
• - le système se trouve dans l'état « source » considéré,
- la condition de validation de la transition est vraie,
- un front actif de l'horloge survient.

 Certaines transitions ont le même état pour source et destination : la

machine reste dans le même état.
E=0
Etat 1
 Transition directe (sans condition): L’état source ne dure qu’une

période d’horloge puis l’état destination est atteint.
Etat 1 Etat 2
S=0 S=1
31
06/11/2023

 Pour les machines de Moore, la valeur des signaux de sortie est placée
à l’intérieur des cercles.
Etat 1 E=1 Etat 2 Valeur de

S=0 S=1 la sortie
 Pour les machines de Mealy, la valeur des signaux de sortie est placée
à côté des flèches de transition - on les sépare des conditions de
transition par une barre oblique /.
Valeur de la sortie
E=1 / S=0
Etat 1 Etat 2

Exemple : digicode
La porte ne s’ouvre (P=1) que si l’on tape la séquence

123 sinon la porte reste fermée (P=0).
32
06/11/2023

Exemple : Machine de Moore
E≠2 4 états !!
E≠1
E0 E=1 E1 E=2 E2 E=3 E3

P=0 P=0 P=0 P=1
E≠3
Clk
E 1 4 1 2 3
Etat
E0 E1 E0 E1 E2 E3 E0
présent
Sortie synchrone
P

Exemple : Machine de Mealy
E≠3 / P=0 3 états !!

E≠1 / P=0 E≠2 / P=0
E=1 / P=0 E=2 / P=0

E0 E1 E2
E=3 / P=1
Clk
E 1 4 1 2 3
Etat
E0 E1 E0 E1 E2 E0
présent
Sortie
P
asynchrone
33
06/11/2023

Exemple : Description VHDL à 2 process
Un process combinatoire
Clk
Etat
E combinatoire Registre combinatoire S
p n d’état n q
Calcul de actuel Calcul de
Etat présent
Mealy
Un process séquentiel

Exemple :Description VHDL de la machine de Moore
Library ieee;
Use ieee.std_logic_1164.all;
Entity digicode is
Port(clk : in std_logic;
E : in integer range 0 to 9; Codage des états:
P : out std_logic ); 1. Déclaration d’un nouveau type
End digicode; contenant les noms des états.
2. Déclaration de deux signaux du
nouveau type : etat_present et
Architecture Arch of digicode is
etat_futur.
Type etat_digicode is (E0, E1, E2, E3);

Signal etat_present, etat_futur : etat_digicode;
Begin
34
06/11/2023

Exemple :Description VHDL de la machine de Moore
Combinatoire : Process(etat_present, E)
Begin Process combinatoire
Case etat_present is sensible à l’état présent
et à l’entrée
When E0 => P<=‘0’;
if E=1 then etat_futur<=E1;
else etat_futur<=E0; end if; Codage des
When E1 => P<=‘0’; transitions et gestion
if E=2 then etat_futur<=E2; de la valeur de
sortie: Gestion des
else etat_futur<=E0; end if; états et des sorties
When E2 => P<=‘0’; avec l’instruction
if E=3 then etat_futur<=E3; Case..is..when
else etat_futur<=E0; end if;
When E3 => P<=‘1’; etat_futur<=E0;
End case;
End process Combinatoire;

Exemple : Description VHDL de la machine de Moore
Process séquentiel sensible à

l’horloge: il décrit le passage d’un
Sequentiel: Process(clk) état à un autre sur les fronts
Begin montants d’horloge.
If clk’event and clk=‘1’ then
etat_present <=etat_futur;
End if;
End process Sequentiel;
End Arch;
35
06/11/2023

Exemple : Description VHDL de la machine de Mealy
Library ieee;
Use ieee.std_logic_1164.all;
Entity digicode is
Port(clk : in std_logic;
E : in integer range 0 to 9;
P : out std_logic );
End digicode;
Architecture Arch of digicode is
Type etat_digicode is (E0, E1, E2);

Signal etat_present, etat_futur : etat_digicode;
Begin

Exemple :Description VHDL de la machine de Mealy
Process combinatoire
sensible à l’état présent
Combinatoire : Process(etat_present, E) et à l’entrée. Il gère les
Begin transitions et la valeur de
Case etat_present is sortie.
When E0 => if E=1 then etat_futur<=E1; P<=‘0’;
else etat_futur<=E0; P<=‘0’; end if;
End case;
End process combinatoire;
36
06/11/2023

Exemple :Description VHDL de la machine de Mealy
Sequentiel: Process(clk)
Begin
If clk’event and clk=‘1’ then
etat_present <=etat_futur;
End if;
End process Sequentiel;
End Arch;
37

Chap3 - SoC - M1 SIIoT

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

Chap3 - SoC - M1 SIIoT

Transféré par

Droits d'auteur :

Formats disponibles

06/11/2023

Année Universitaire 2023-2024

 Le VHDL permet la programmation des circuits logiques pragrammables

 C’est un langage de haut niveau adapté à la description fonctionnelle de

 Le VHDL est un langage de test permettant la validation d’un composant aux

 Concurents : verilog HDL et systemC.

 Outils logiciels : modelSim, Quartus II (Intel), ISE et vivado (Xilinx)

2. Structure d’une description VHDL

 Exemple : Additionneur 1 bit (demi-additionneur)

M. FEKI – Architecture des SoCs 4

2. Structure d’une description VHDL

-- ceci est un commentaire

M. FEKI – Architecture des SoCs 5

2. Structure d’une description VHDL

Library ieee; -- la bibliothèque ieee

 Pour réaliser certaines opérations (exemple : opérations signés ou non signés,

M. FEKI – Architecture des SoCs 6

2. Structure d’une description VHDL

ENTITY <nom de l’entité> IS

M. FEKI – Architecture des SoCs 7

2. Structure d’une description VHDL

- std_logic ‘0’ ou ‘L’ niveau bas

- std_logic_vector ((n-1) downto 0) (vecteur de n bits)

 Exemple : un bus d’entrée de 4 bits

M. FEKI – Architecture des SoCs 8

2. Structure d’une description VHDL

ENTITY <nom de l’entité> IS

Remarque : L’affectation d’une valeur par défaut est facultatif.

2. Structure d’une description VHDL

ARCHITECTURE <nom de l’architecture> OF <nom de l’entité> IS

 Déclaration d’un signal interne

 Déclaration d’une constante

Une constante prend sa valeur au

M. FEKI – Architecture des SoCs 10

2. Structure d’une description VHDL

 Les bases numériques utilisées pour un bus peuvent être :

Bus <= “1001” ; --bus = 9 en décimal

M. FEKI – Architecture des SoCs 12

 Elle permet de joindre des signaux entre eux.

 Exemple : Soit A et B de type vecteur de 3 bits et S de type vecteur de 8

S <= A & B & “01” ; --S prend la valeur suivante

M. FEKI – Architecture des SoCs 13

M. FEKI – Architecture des SoCs 14

 Pour réaliser des décalages et des rotations logiques, il est préférable

A<=“01011111” ; --A est un std_logic_vector(7 downto 0)

S<= A(6 downto 0) & ‘0’; --décalage d’un bit à gauche

S<= A(2 downto 0) & A(7downto 3); --rotation de 3 bits à

M. FEKI – Architecture des SoCs 16

 Pour pouvoir utiliser les opérateurs arithmétiques, il faut rajouter la

M. FEKI – Architecture des SoCs 17

M. FEKI – Architecture des SoCs 18

4. Les instructions concurrentes

Les instructions concurrentes sont exécutées simultanément. L’ordre des

<signal> <= <expression 1> WHEN <condition1> ELSE

M. FEKI – Architecture des SoCs 19

4. Les instructions concurrentes

4 S <= E1 WHEN SEL= "00" ELSE

M. FEKI – Architecture des SoCs 20

4. Les instructions concurrentes

WITH <signal de selection> SELECT

M. FEKI – Architecture des SoCs 21

4. Les instructions concurrentes

L’instruction GENERATE permet de créer des structures répétitives et