Les machines à états finis

(FSM)
Les machines à états finis

Les machines à états finis

Les machines à états finis permettent de modéliser des
circuits séquentiels complexes.

AU 2021/2022 198
 Les machines à états finis

• FSM Finite State Machine

• Outil pour représenter un système séquentiel
• On définit différents états dans lesquels peut être le système
• Le passage d’un état à un autre s’effectue si une condition sur
les entrées est remplie
• Les sorties du système dépendent de l’état courant (machine de
Moore) ou de l’état courant et des entrées (machine de Mealy)
• Dans le cas d’une FSM synchrone, la valeur des entrées est
analysée sur front d’horloge

AU 2021/2022 199
Les machines à états finis

• Machine de Moore

Horloge c

Entrées Circuit d'excitation X(t+1) X(t) Circuit S(t)

Calcul combinatoire D Q de sortie
E(t) des états FUTURS F
du système : G

S(t) = F(X(t))
X(t + 1) = G[E(t), X(t)]

AU 2021/2022 200
Les machines à états finis

• Machine de Mealy

Horloge c Circuit S(t)

de sortie
Circuit d'excitation X(t+1) X(t) F
Calcul combinatoire D Q
E(t) des états FUTURS
du système : G
Entrées

S(t) = F[X(t), E(t)]

X(t + 1) = G[E(t), X(t)]

AU 2021/2022 201
 Les machines à états finis
Exemple : détecteur de séquence

La porte ne s’ouvre que si l’on tape la séquence

‘1’ ‘2’ ‘3’
•Etat 0 : le système attend un ‘1’ en entrée,
la porte est fermée (P=0)

•Etat1 : le système attend un ‘2’ en entrée,

la porte est fermée (P=0)

•Etat2 : le système attend un ‘3’ en entrée,

la porte est fermée (P=0)

•Etat3 : la bonne séquence a été entrée,

la porte est ouverte (P=1)
AU 2021/2022 202
 Les machines à états finis
Exemple : détecteur de séquence

Entrée ≠ ‘1’ On représente une machine à état

par un graphe d’état
P=0
E0

Entrée ≠ ‘2’ Entrée = ‘1’

E1 P=0 Entrée ≠ ‘3’

1=1
Entrée = ‘2’

P=0 E2

Entrée = ‘3’

E3 P=1

AU 2021/2022 203
 Les machines à états finis

Graphe d’état
Définition :
•Un diagramme ou graphe d’états permet d’avoir une représentation
graphique d’un système séquentiel.
•Il est constitué par l’énumération de tous les états possible du système.
•Un seul de ces états peut être actif à la fois.
•A chaque état est associé la valeur de la (ou des) grandeur(s) de sortie.
Transition Etat

1 2

Valeur de la (ou des) sortie(s) s=1 s=0

AU 2021/2022 204
 Les machines à états finis

Codage des états

• Codage binaire
Le numéro de l’état est codé en binaire
état 0 = "00", état 1 = "01", état 2 = "10", état 3 = "11"
• One-Hot-One
Chaque état correspond à 1 bit d’un même bus
état 0 * state = "0001", état 1 * state = "0010",
état 2 * state = "0100", état 3 * state = "1000"
• One-Hot-Zero
Même principe que One-Hot-One mais l’état 0 se code "0000"

AU 2021/2022 205
Les machines à états finis

AU 2021/2022 206
 Les machines à états finis

Quelques règles à respecter pour la synthèse de FSM :

* Déclarer un type énumérant tous les états de la machine

* Affecter des valeurs par défaut au sorties de la machine à états pour

éviter la génération de latches

* Prévoir une clause par défaut dans le cas ou le circuit se trouve dans un
état non utilisé

* Séparer la machine à états des fonctions logiques

* Si le résultat d’une opération est utilisé par plusieurs états, il faut définir
l’opération à l’extérieure de la machine à états

* Utiliser un reset (synchrone ou asynchrone)

AU 2021/2022 207
 Les machines à états finis

 Description VHDL
Les FSM sont composées de trois parties: deux fonctions
combinatoires et un registre.

Chacune de ces parties peut être décrite séparément ou de

manière composée avec une autre .

Les états peuvent être identifiés explicitement à l'aide d'un type

énuméré approprié !

Exemple :

TYPE state IS (lecture, incrément, décode, exécute) ;

AU 2021/2022 208
 Les machines à états finis

• Description à trois parties

ARCHITECTURE FSM3p of exemple IS
TYPE state IS (lecture, incrément, décode, exécute) ;
signal etat, etat_futur : state ;
BEGIN
Pr : process(horloge)
..... IF horloge'event ....
Horloge c

...... etat <= etat_futur ; E

etat_futur
ps : process(etat) Pe Pr
etat
Ps
S
..... S <= ....
pe : process(E, etat)
...... etat_futur <= ...

AU 2021/2022 209
Les machines à états finis

 Commande d'essuie glace

On considère un essuie glace avec pompe de lavage. Le
maintien de la commande E active le moteur M de balayage
simultanément au moteur de pompe P. La libération de E arrête
la pompe P. Le moteur M reste activé pendant deux cycles
complet de balayage. Le système est équipé d'un contact de fin
de course F.

Représenter le graphe de la machine d'état du dispositif. Décrire

la machine en VHDL.

AU 2021/2022 210
Les machines à états finis

• Commande d'essuie glace

!E
repos
F !M, !P
E

E
cyc_2 lavage
! F M , !P M, P E
E
F !E
cyc_1
M, !P
!F

AU 2021/2022 211
Les machines à états finis
Type state is (repos, lavage, cyc_1, cyc_2)
signal etat, etat_f : state;
P1 : process(clk)
begin
if clk'event and clk='1' then
etat <= etat_f;
Registre
end if;
end process P1;
P2 : process(etat)
begin
if etat= repos then
M <= '0'; P <= '0';
elsif etat = lavage then Description
M <= '1'; P <= '1'; des sorties
else
M <= '1'; P <= '0';
end if;
end process P2;
AU 2021/2022 212
Les machines à états finis
P3 : process(F, E, etat) Circuit
begin
d'excitation
case etat is
when repos => if E='1' then
etat_f <= lavage ;
else etat_f <= etat; end if;
when lavage => if E = '0' then
etat_f <= cyc_1 ;
else etat_f <= etat; end if;
when cyc_1 => if E ='1' then
etat_f <= lavage ;
elsif F= '1' then etat_f <= cyc_2 ;
else etat_f <= cyc_1; end if;
when cyc_2 => if E = '1' then
etat_f <= lavage ;
elsif F= '1' then etat_f <= repos ;
else etat_f <= etat; end if;
end process P3;
AU 2021/2022 213
Les machines à états finis

Simplification de l'écriture
Il est possible de regrouper les parties combinatoires dans
un processus, ce qui allège l'écriture au détriment de la
lisibilité.

Pour l'exemple cela donne :

Type state is (repos, lavage, cyc_1, cyc_2)

signal etat, etat_f : state;
reg : process(clk)
begin
if clk'event and clk='1' then
etat <= etat_f;
end if;
end process reg ;
AU 2021/2022 214
Les machines à états finis
P3 : process(F, E, etat)
begin
case etat is
when repos => M <= '0'; P <= '0' Etats de sorties
if E='1' then etat_f <= lavage ;
else etat_f <= etat; end if;
when lavage => M <= '1'; P <= '1';
if E = '0' then etat_f <= cyc_1 ; Etat futur
else etat_f <= etat; end if;
when cyc_1 => M <= '1'; P <= '0';
if E ='1' then etat_f <= lavage ;
elsif F= '1' then etat_f <= cyc_2 ;
else etat_f <= etat; end if;
when cyc_2 => M <= '1'; P <= '0';
if E = '1' then etat_f <= lavage ;
elsif F= '1' then etat_f <= repos ;
else etat_f <= etat; end if;
end process P3;
AU 2021/2022 215
 Les machines à états finis

Autre simplification: Créer un registre à la fin du circuit

d’excitation. Pour l'exemple cela donne :

Type state is (repos, lavage, cyc_1, cyc_2)

signal etat : state;
-- pas de process registre
P2 : process(etat)
Etats de sorties
begin
if etat= repos then
M <= '0'; P <= '0';
elsif etat = lavage then
M <= '1'; P <= '1';
else
M <= '1'; P <= '0';
end if;
end process P2;

AU 2021/2022 216
Les machines à états finis
P3 : process(F, E, etat)
Begin
if clk'event and clk='1' then
case etat is Description du
when repos => registre d’état
if E='1' then etat <= lavage ;
else etat <= etat; end if;
when lavage =>
if E = '0' then etat <= cyc_1 ;
else etat <= etat; end if;
when cyc_1 =>
if E ='1' then etat <= lavage ;
elsif F= '1' then etat <= cyc_2 ;
else etat <= etat; end if;
when cyc_2 =>
if E = '1' then etat <= lavage ;
elsif F= '1' then etat <= repos ;
else etat <= etat; end if;
end case;
end process P3;
AU 2021/2022 217
Les packages
Paquetages

AU 2021/2022 219
Paquetage STANDARD

Le paquetage STANDARD déclare les

types et sous-types prédéfinis du langage, la
fonction now (qui retourne le temps simulé
courant) et l'attribut foreign.
Les déclarations du paquetage STANDARD
sont automatiquement visibles dans toute
unité de conception.

AU 2021/2022 220
 Paquetage TEXTIO
Le paquetage prédéfini TEXTIO déclare des types et des sous-programmes pour la
manipulation de fichiers textes. Il déclare aussi des procédures pour lire et écrire les valeurs
d'objets de types prédéfinis.
La lecture d'un fichier texte est effectuée en deux étapes:
1) lire une ligne complète avec la procédure read-line et stocker la ligne dans un tampon de
type line,
2) lire chaque élément de la ligne lue avec l'une des version de la procédure read relative au
type de valeur à lire. La procédure read peut retourner l'état de l'opération par le
paramètre good.
L'écriture dans un fichier est aussi effectuée en deux étapes:
1) une ligne complète est construite dans un tampon de type line au moyen d'une des
versions de la procédure write, en fonction des types de valeurs à écrire,
2) la ligne est écrite dans le fichier avec la procédure write-line.
AU 2021/2022 221
Paquetage TEXTIO

AU 2021/2022 222
 Paquetage STD_LOGIC_1164
Le paquetage STD_LOGIC_1164 ne fait pas partie de la définition du langage VHDL,
mais est défini comme un standard séparé.
Le paquetage déclare deux types logiques à neuf états std_ulogic et std_logic :
• Les états '0', '1' et 'X' représentent respectivement l'état faux, vrai et inconnu (ou
indéterminé).
• Les états 'L', 'H' et 'W' représentent des états résistifs du type pull-down ou pull-up.
• L'état 'Z' représentent un état haute-impédance.
• L'état 'U' est l'état initial par défaut et identifie les signaux qui n'ont pas été affectés en
simulation.
• L'état '-' est parfois utilisé pour des vecteurs de test ou en synthèse pour spécifier que
certains bits ne sont pas importants.

AU 2021/2022 223
Paquetage STD_LOGIC_1164

AU 2021/2022 224
 Paquetage STD_LOGIC_1164
Le paquetage déclare des versions des opérateurs logiques pour ces nouveaux types. Il
n'est par contre pas possible d'utiliser sans autre des opérateurs arithmétiques sur des
objets appartenant à ces types.
L'utilisation du paquetage STD_LOGIC_1164 dans une unité de conception requiert la
spécification d'une clause de contexte.
Le corps de paquetage inclut les corps des sous-programmes déclarés dans la déclaration
de paquetage correspondante.
A titre d'exemple, la fonction de résolution resolve utilise une table constante
resolution_table pour définir les valeurs résolues de toutes les paires de sources possibles.
Le corps de la fonction traite d'abord le cas pour lequel le signal résolu n'a qu'une seule
source de manière à optimiser le temps de calcul. Dans le cas contraire, une boucle est
utilisée pour appliquer la table de résolution à chaque source du signal.

AU 2021/2022 225
Paquetage STD_LOGIC_1164

AU 2021/2022 226
Paquetage MATHEMATIQUE

AU 2021/2022 227
Paquetage NUMERIC_BIT

AU 2021/2022 228
Paquetage NUMERIC_STD

AU 2021/2022 229
VHDL pour la synthèse
 VHDL pour la synthèse

Les outils de synthèse utilisent un sous ensemble du VHDL

standard

Les outils de synthèse reconnaissent des styles de codage

* Les outils sont différents les un des autres
* Il faut donc bien connaître son outil de synthèse et les formats utilisés

Les codes VHDL avant et après synthèse peuvent être

différents
* Utilisation des outils de vérification formelle et de la simulation après-
synthèse

AU 2021/2022 231
VHDL pour la synthèse

IEEE Std 1076.6-1999

*IEEE Standard for VHDL Register Transfer Level (RTL)
Synthesis
IEEE Std 1076.3-1997
*IEEE Standard Synthesis Packages
❖ Package NUMERIC_BIT
Basé sur le type BIT de VHDL
2 sous types : UNSIGNED et SIGNED
❖ Package NUMERIC_STD
Basé sur le type STD_LOGIC
2 sous types : UNSIGNED et SIGNED

AU 2021/2022 232
VHDL pour la synthèse

Types supportés
*Types énumérés :
❖ boolean, bit et character
*Types entiers :
❖ integer
*Types array d’éléments scalaires :
❖ bit_vector et string
*std_ulogic, std_ulogic_vector, std_logic et std_logic_vector, du
package std_logic_1164
*unsigned et signed, du package numeric_bit
*unsigned et signed, du package numeric_std
Types non supportés
*Types réels : real
*Types physiques : time

AU 2021/2022 233
VHDL pour la synthèse

Opérations :

* logical_operator ::= and | or | nand | nor | xor | xnor

* relational_operator ::= = | /= | < | <= | > | >=
* shift_operator ::= sll | srl | sla | sra |
rol | ror
❖ Remplacés par les fonctions SHIFT_LEFT et SHIFT_RIGHT des
packages NUMERIC_STD et NUMERIC_BIT
* adding_operator ::= +|-|&
* sign ::= +|-
* multiplying_operator ::= * | / | mod | rem
* miscellaneous_operator ::= ** | abs | not

AU 2021/2022 234
VHDL pour la synthèse
 Affectation d’un signal
signal_assignment_statement ::=
[ label : ] target <= [ delay_mechanism ] waveform ;

delay_mechanism ::=
transport | [ reject time_expression ] inertial

waveform ::= waveform_element { , waveform_element } | unaffected

waveform_element ::= value_expression [ after time_expression ] | null

[
after time expression ]

AU 2021/2022 235
VHDL pour la synthèse

Instructions séquentielles
*WAIT
❖ Une seule instruction wait par process
❖ L’instruction wait doit être au début du process
❖ Pas de wait for
*IF
❖ Si un signal est affecté sous seulement certaines conditions de
l’instruction IF, un élément mémoire peut être créé
*CASE
*LOOP
❖ WHILE n’est pas supporté
❖ FOR avec un intervalle statique de valeurs entières

AU 2021/2022 236
VHDL pour la synthèse

Instructions concurrentielles
* BLOCK
* PROCESS
❖ Postponed n’est pas supporté
* Affectation conditionnelle
❖ Affectation avec WHEN
❖ Affectation WITH … SELECT
* GENERATE
* Instructions d’initialisation de signaux

AU 2021/2022 237
VHDL pour la synthèse

Attributs d’un signal S

* s'DELAYED[(t)]
* s'STABLE[(t)]
* s'QUIET
* s'TRANSACTION
* s'EVENT
* s'ACTIVE
* s'LAST_EVENT
* s'LAST_ACTIVE
* s'LAST_VALUE
* s'DRIVING
* s'DRIVING_VALUE

AU 2021/2022 238
VHDL pour la synthèse

Front montant de l’horloge CLK

*En utilisant l’expression IF avec CLK dans la liste de
sensibilité
❖ 1. IF RISING_EDGE (clk)
❖ 2. IF clk’EVENT and clk = ‘1’
❖ 3. IF clk = ‘1’ and clk’EVENT
❖ 4. IF not clk’STABLE and clk = ‘1’
❖ 5. IF clk = ‘1’ and not clk’STABLE

Note : Même chose pour le front descendant de CLK en utilisant FALLING_EDGE

au lieu de RISING_EDGE et CLK =‘0’ au lieu de clk = ‘1’

AU 2021/2022 239
VHDL pour la synthèse

Front montant de l’horloge CLK

*En utilisant l’expression WAIT sans clk dans la liste de
sensibilité
❖ 1. Wait until RISING_EDGE (clk)
❖ 2. Wait until clk = ‘1’
❖ 3. Wait until clk’EVENT and clk = ‘1’
❖ 4. Wait until clk = ‘1’ and clk’EVENT
❖ 5. Wait until not clk’STABLE and clk = ‘1’
❖ 6. Wait until clk = ‘1’ and not clk’STABLE

Note : L’instruction WAIT doit être la première instruction du process Une seule
instruction WAIT par process

AU 2021/2022 240
Banc d’essai « testbench »

Le banc d’essai représente le module de plus haut niveau

pour le système à vérifier
* Il ne contient pas de signal d’interface
* Il instancie tous les composants nécessaires du système
❖ Utilisation de configuration pour vérifier plusieurs architectures d’un
même système

Le banc d’essai peut être utilisé pour :

* Générer les stimuli (vecteurs de test)
* Appliquer des stimuli au système à vérifier
* Comparer les réponses aux stimuli du systèmes à vérifier avec les
bonnes réponses

AU 2021/2022 241
Un bon code HDL

Commentaires intelligents
* Mauvais commentaire
❖ i := i +1 ; -- incrémenter la valeur de i
* Bon
commentaire -- incrémenter la valeur du compteur jusqu’à
❖ i := i+1 -- atteindre la valeur 4, ce qui permet de diviser
❖
❖
le signal d’entrée par 8

Écrire le code en fonction de l’outil et de l’objectif recherché

* Simulation, synthèse, banc d’essai, ..etc.
* Comprendre le fonctionnement et les limitations de notre outil
Partir toujours d’un bon code existant
* Ça permet de gagner du temps et d’avoir un bon code
* Utiliser les gabarits « templates » fournis par les outils de conception

AU 2021/2022 242
Conclusion

CODE VHDL

Structure Types Déclarations Opérations Instructions

Library Scalaires Constant Logiques Séquentielles

Package Composés Signal Relationnelles Concurrentielles

Entity File Variable Arithmétiques

Architecture Access File Décalage

Autres

AU 2021/2022 243
Conclusion

Ce qu’il faut retenir :

* Structure d’un code VHDL
* Les niveaux de description
* Les objets
* La notion de « process »
* Les opérations et les instructions
* La simulation en VHDL
* VHDL pour la synthèse

AU 2021/2022 244