Vous êtes sur la page 1sur 61

VHDL – Logique programmable 1/61 Partie 7 - Diagrammes d’état

VHDL - Logique programmable


Partie 7 - Les diagrammes d’état

Denis Giacona

ENSISA
École Nationale Supérieure d'Ingénieurs Sud Alsace
12, rue des frères Lumière
68 093 MULHOUSE CEDEX
FRANCE

Tél. 33 (0)3 89 33 69 00

© D.Giacona
VHDL – Logique programmable 2/61 Partie 7 - Diagrammes d’état

1.  Le concept des machines à états (FSM: Finite State Machine) ........................................................................................................... 6 
1.1.  Propriétés générales des machines synchrones ................................................................................................................................. 6 
1.2.  Les types de machine à états ................................................................................................................................................................. 7 
1.2.1.  La machine de Moore ......................................................................................................................................................................... 7 
1.2.2.  La machine de Mealy .......................................................................................................................................................................... 7 
1.2.3.  La machine mixte ................................................................................................................................................................................ 7 
1.3.  Structure d'une machine de Moore / Mealy à sorties combinatoires .......................................................................................... 8 
1.3.1.  Comportement des sorties combinatoires – machine de Moore .............................................................................................. 9 
1.3.2.  Comportement des sorties combinatoires – machine de Mealy............................................................................................... 9 
1.4.  Structure d'une machine Moore / Mealy à sorties synchronisées .............................................................................................. 10 
1.5.  Structure d'une machine de Moore – sorties prises directement dans l’état interne ............................................................ 11 
1.6.  Codage des états internes de la machine .......................................................................................................................................... 12 
1.6.1.  Choix du code .................................................................................................................................................................................... 12 
1.6.2.  États codés ........................................................................................................................................................................................ 13 
1.6.3.  États décodés (One hot state machine) .................................................................................................................................... 15 
2.  Applications des machines à états ............................................................................................................................................................. 16 
2.1.  Les registres de mémorisation ............................................................................................................................................................. 16 
2.2.  Les registres à décalage ........................................................................................................................................................................ 17 
2.3.  Les registres de comptage .................................................................................................................................................................... 18 
2.4.  Les contrôleurs ........................................................................................................................................................................................ 19 
2.4.1.  Rôle d’un contrôleur ......................................................................................................................................................................... 19 
3.  Règles de conception pour un fonctionnement sûr ................................................................................................................................. 21 
3.1.  Paramètres temporels et horloge ....................................................................................................................................................... 22 
3.1.1.  Paramètres temporels des systèmes combinatoires .............................................................................................................. 22 
3.1.2.  Paramètres temporels des systèmes séquentiels (fréquence max d’horloge) .................................................................. 23 
3.2.  La synchronisation des entrées asynchrones................................................................................................................................... 24 

© D.Giacona
VHDL – Logique programmable 3/61 Partie 7 - Diagrammes d’état

3.2.1.  L’état métastable ............................................................................................................................................................................ 24 


3.2.2.  Conception correcte : synchronisation des entrées asynchrones ....................................................................................... 25 
3.3.  Les erreurs dues à des événements extérieurs .............................................................................................................................. 26 
3.4.  Erreurs conduisant à des états inutilisés ......................................................................................................................................... 27 
3.4.1.  Cas des machines comportant un code complet ....................................................................................................................... 28 
3.4.2.  Méthodes de détection et de correction des erreurs ........................................................................................................... 29 
3.5.  Les hasards statiques ............................................................................................................................................................................ 30 
3.6.  Les états internes transitoires ............................................................................................................................................................ 31 
4.  Le modèle diagramme/graphe d'état dans l’outil Active-HDL (Aldec) ............................................................................................ 32 
4.1.  Style de codage VHDL d’un diagramme d’états............................................................................................................................... 32 
4.2.  Les nœuds d’un graphe .......................................................................................................................................................................... 34 
4.2.1.  Le cercle d'état ............................................................................................................................................................................... 34 
4.2.2.  L'arc ................................................................................................................................................................................................... 35 
4.3.  La dynamique d’un graphe ..................................................................................................................................................................... 36 
4.3.1.  L’horloge ............................................................................................................................................................................................ 36 
4.3.2.  La transition avec condition .......................................................................................................................................................... 37 
4.3.3.  La transition directe (sans condition) ........................................................................................................................................ 39 
4.3.4.  La priorité d’une transition ........................................................................................................................................................... 40 
5.  Les paramètres des états d’un graphe ...................................................................................................................................................... 41 
5.1.  Le codage des états ................................................................................................................................................................................ 41 
5.2.  L’état de repli d’un graphe.................................................................................................................................................................... 42 
5.3.  L’état initial d’un graphe ....................................................................................................................................................................... 43 
5.4.  Les macro-états ...................................................................................................................................................................................... 44 
6.  Les actions ...................................................................................................................................................................................................... 45 
6.1.  Actions concurrentes associées à l’ensemble d’un diagramme d’états ...................................................................................... 46 
6.2.  Action d’état – assignation combinatoire de la sortie ................................................................................................................... 47 
6.3.  Action de transition – assignation combinatoire de la sortie ...................................................................................................... 50 

© D.Giacona
VHDL – Logique programmable 4/61 Partie 7 - Diagrammes d’état

6.4.  Action d’état de comptage ................................................................................................................................................................... 53 


6.5.  Une application pour carte Brevia 2 (Lattice) ................................................................................................................................. 58 

© D.Giacona
VHDL – Logique programmable 5/61 Partie 7 - Diagrammes d’état

Experience has shown that the safest methodology for time-domain control of an
ASIC is synchronous design.

A synchronous circuit is one in which:


 all data storage elements are clocked, and in normal operation change state only
in response to the clock signal
 the same active edge of a single clock signal is applied at precisely the same
point in time at every clocked cell in the device.

Extrait d’un
document ATMEL

© D.Giacona
VHDL – Logique programmable 6/61 Partie 7 - Diagrammes d’état

1. Le concept des machines à états (FSM: Finite State Machine)

1.1. Propriétés générales des machines synchrones

 Les sorties sont évaluées à partir d’un état interne qui englobe toute l’information
relative au passé des entrées

 L’état interne est mémorisé dans le registre d’état (un ensemble de flip-flops)

 Un état interne futur se déduit de l’état interne présent et des entrées du système

 Dans une machine d’état synchrone l’évolution de l'état interne ne se produit que sur
un front d'une horloge

 La durée minimum d’un état interne est toujours garantie (c’est un multiple de la
période d’horloge)

 Tout système séquentiel synchrone peut être considéré comme une machine d'état ou
une combinaison de machines d'état.

© D.Giacona
VHDL – Logique programmable 7/61 Partie 7 - Diagrammes d’état

1.2. Les types de machine à états

1.2.1. La machine de Moore

Les sorties ne dépendent que de l’état courant.

E.F. Moore, “Gedanken-experiments on sequential machines”, Automata Studies, Princeton University


Press, 1956

1.2.2. La machine de Mealy

Les sorties dépendent de l’état interne courant et des entrées.

G.H. Mealy, “A method for synthesizing sequential circuits”, Bell System Technical Journal, 1955

1.2.3. La machine mixte

Combinaison de sorties de type Mealy et de sorties de type Moore.

© D.Giacona
VHDL – Logique programmable 8/61 Partie 7 - Diagrammes d’état

1.3. Structure d'une machine de Moore / Mealy à sorties combinatoires

 Principe : les sorties sont élaborées par un bloc combinatoire de décodage du registre
d’état.
 Inconvénients :
o délai supplémentaire après le changement d’état interne de la machine
o apparition en sortie d’impulsions parasites de courte durée dues, aux hasards
statiques (glitches) lorsque les couches combinatoires ont des longueurs
différentes, et aux changements d’état transitoires des bits du registre d’état

next_state state_reg outputs


x
a current_state
(Combinatoire) (Flip-flops) (Combinatoire)
b y

Mealy clk

© D.Giacona
VHDL – Logique programmable 9/61 Partie 7 - Diagrammes d’état

1.3.1. Comportement des sorties combinatoires – machine de Moore

Les sorties ne changent pas d’état directement en réponse au changement d’état des
entrées, mais suite au changement d’état de la machine, donc indirectement
consécutivement à un front d’horloge.

1.3.2. Comportement des sorties combinatoires – machine de Mealy

Les sorties peuvent changer d’état directement en réponse au changement d’état des
entrées, même entre deux fronts d’horloge.

© D.Giacona
VHDL – Logique programmable 10/61 Partie 7 - Diagrammes d’état

1.4. Structure d'une machine Moore / Mealy à sorties synchronisées

 Les sorties sont préparées avant le front actif d’horloge


 Les changements d'état des sorties ont tous lieu simultanément, sur le même front
d’horloge
 Avantage : pas de hasard statique, indépendance vis-à-vis des changements d’état
transitoires des bits du registre d’état
 Inconvénient : il faut un flip-flop supplémentaire par sortie

next_state state_reg
a
(Combinatoire) (Filp-flops)
b
current_state

clk

Outputs output_reg
x
(Combinatoire) (Flip-flops)
Mealy
y

clk

© D.Giacona
VHDL – Logique programmable 11/61 Partie 7 - Diagrammes d’état

1.5. Structure d'une machine de Moore – sorties prises directement dans


l’état interne

 Les bits du registre d’état fournissent directement les sorties

 Avantage : pas de bloc combinatoire de sortie

 Inconvénient : méthode applicable uniquement dans des cas particuliers

current_state

next_state state_reg

a (Combinatoire) (Filp-flops)
x, y
b

clk

© D.Giacona
VHDL – Logique programmable 12/61 Partie 7 - Diagrammes d’état

1.6. Codage des états internes de la machine


1.6.1. Choix du code

 Binaire en séquence naturelle


 Gray
 Johnson
 One Hot (un seul bit actif dans chaque combinaison)
 Two Hot
 Autres (spécifiques) 0

Par exemple pour coder 8 états :


1 2

Numéro état Binaire naturel Gray Johnson One-hot Autres


0 000 000 0000 00000001 à définir
1 001 001 0001 00000010 à définir 3 4
2 010 011 0011 00000100 à définir
3 011 010 0111 00001000 à définir
4 100 110 1111 00010000 à définir 5
5 101 111 1110 00100000 à définir
6 110 101 1100 01000000 à définir
7 111 100 1000 10000000 à définir 7
3 bits 3 bits 4 bits 8 bits à définir 6

© D.Giacona
VHDL – Logique programmable 13/61 Partie 7 - Diagrammes d’état

1.6.2. États codés

 Chaque état interne est représenté par un code binaire dans lequel plusieurs bits sont
à ‘1’
 La génération des sorties nécessite un post-décodage du registre d’état (logique
combinatoire de sortie)
 Ils requièrent un minimum de flip-flops
 Si le nombre d’états est élevé, ils génèrent une logique combinatoire complexe pour le
calcul de l’état futur
 C’est une méthode adaptée aux circuits CPLD (moins de flip-flops que dans les FPGA)

110

q(2:0)
next_state state_reg
current-state
a
(Combinatoire) (Flip-flops)
b

clk

© D.Giacona
VHDL – Logique programmable 14/61 Partie 7 - Diagrammes d’état

Code binaire naturel


 Le nombre de flip-flops m est minimal (jusqu’à 2m états possibles)
 Il peut y avoir des états inutilisés  prévoir des échappatoires (sinon risque de
blocage)

Code Johnson
 Registre à décalage avec rétroaction complémentée
 Pour n flip-flops on peut coder 2n états
 Il comporte des états inutilisés

Code Gray (code binaire réfléchi)


 Le nombre de flip-flops m minimal (jusqu’à 2m états)
 Un seul bit change de valeur entre deux états consécutifs  pas d’états transitoires
si le code est complet
 Il peut y avoir des états inutilisés

© D.Giacona
VHDL – Logique programmable 15/61 Partie 7 - Diagrammes d’état

1.6.3. États décodés (One hot state machine)

 Chaque état interne de la machine est représenté par un seul bit : c.-à-d. en
fonctionnement normal, un seul flip-flop du registre d’état est à ‘1’, les autres sont à
‘0’
 C’est une méthode adaptée aux circuits FPGA qui comportent un grand nombre de flip-
flops
 La logique combinatoire de calcul de l’état futur est plus simple que pour les états
codés
10000000

next_state state_reg q(7:0)


a current_state
(Combinatoire) (Flip-flops)

clk

© D.Giacona
VHDL – Logique programmable 16/61 Partie 7 - Diagrammes d’état

2. Applications des machines à états

2.1. Les registres de mémorisation

 Entrées à next_state Sorties


mémoriser mémorisées
 Entrées de (Combinatoire) d q
commande

clk

© D.Giacona
VHDL – Logique programmable 17/61 Partie 7 - Diagrammes d’état

2.2. Les registres à décalage

next_state Sorties
 Entrées de
commande d q
 Données à charger (Combinatoire)
clk

© D.Giacona
VHDL – Logique programmable 18/61 Partie 7 - Diagrammes d’état

2.3. Les registres de comptage

next _state outputs


 Entrées de Sorties
commande
(Combinatoire) d q (Combinatoire)
 Données à
charger clk

Note : il est aussi possible de décrire le tout en un seul processus.

© D.Giacona
VHDL – Logique programmable 19/61 Partie 7 - Diagrammes d’état

2.4. Les contrôleurs

2.4.1. Rôle d’un contrôleur


Fonction 1

Fonction 2

Machine d’état
servant de pilote.
Contrôleur

Elle décide « qui Fonction 3


fait quoi, quand ».

Donnée

Ordre (activation, validation, déclenchement, arrêt, sélection)

Compte rendu

© D.Giacona
VHDL – Logique programmable 20/61 Partie 7 - Diagrammes d’état

Fonction 1

If clk’event and clk = ‘1’ then


If initialiser = ‘1’ then
clk q <= 0;
elsif compter = ‘1’ then
q <= q + 1;
else q <= q;
end if;
Fonction 2

If clk’event and clk = ‘1’


donnée sortie
then
initialiser compter
If charger = ‘1’ then
clk q <= donnée ;
else q <= q;
end if;
Terminologie : valeur
 Graphe d’état |
 Diagramme d’état | Contrôleur
 Automate à états
charger
finis Initialiser <= ‘1’ ;

clk a = ‘1’

a Compter <= ‘1’ ;

b = ‘1’ valeur = 99
b
Charger <= ‘1’ ;

© D.Giacona
VHDL – Logique programmable 21/61 Partie 7 - Diagrammes d’état

3. Règles de conception pour un fonctionnement sûr

 Une seule horloge. Pas de décalages d’horloge (clock skew) sur les blocs séquentiels
(dans les FPGA, utiliser les ressources de routage prévus pour la distribution de
l’horloge)
 Synchroniser les entrées de données asynchrones
 but : assurer la cohérence des signaux de commande du registre d’état
 Détecter ou corriger les erreurs consécutives à des événements extérieurs
(radiations en milieu hostile : terrestres ou dans l’espace)
 objectif : éviter les blocages de la machine d’état
 Ne pas appliquer les signaux combinatoires sujets aux hasards statiques sur les entrées
asynchrones des blocs séquentiels (par exemple, ne pas fabriquer de signaux d’horloge
avec des portes). Synchroniser si nécessaire les sorties
 S’assurer que les machines d’état démarrent dans des états valides. Initialiser les
flip-flops à la configuration
 Choisir un codage adéquat pour le registre d’état

© D.Giacona
VHDL – Logique programmable 22/61 Partie 7 - Diagrammes d’état

3.1. Paramètres temporels et horloge

3.1.1. Paramètres temporels des systèmes combinatoires

Comb 1

Comb 3 Comb 4
Sorti
Entrée

Comb 2

Disponibilité de la sortie :

à t = date d’arrivée des entrées + max(tpd1, tpd2) + tpd3 + tpd4

tpd : temps de propagation à travers un bloc combinatoire (propagation delay)

© D.Giacona
VHDL – Logique programmable 23/61 Partie 7 - Diagrammes d’état

3.1.2. Paramètres temporels des systèmes séquentiels (fréquence max d’horloge)

Séq 1 Comb 1 Séq 2

clk (période T)

Horloge unique

tco Tpd Tsu


Disponibilité de la sortie :

à T, puis 2T, puis 3T, …

avec T = tco + tpd1 + tsu + marge

tco : clock to output time


tsu : set up time

© D.Giacona
VHDL – Logique programmable 24/61 Partie 7 - Diagrammes d’état

3.2. La synchronisation des entrées asynchrones

 Les états métastables ne peuvent pas être éliminés.


 Leur occurrence est aléatoire.

3.2.1. L’état métastable

sig_async
D Q clk
tCO
clk FF1

tsu États

th possibles
D Q des 
FF2 signaux Q

 Si le signal d’entrée asynchrone sig_async change d’état dans la zone critique [tsu,th], les flip-
flops FF1 et FF2 peuvent entrer dans des états métastables.
 Si l’un des deux flip-flops réagit bien et l’autre non (car ils peuvent avoir des caractéristiques
physiques différentes), il y a incohérence des signaux sur leurs sorties.

© D.Giacona
VHDL – Logique programmable 25/61 Partie 7 - Diagrammes d’état

3.2.2. Conception correcte : synchronisation des entrées asynchrones

 On retarde …  On partage

sig_async q0 d1 q1
D Q D Q
FF0 FF1
 On obtient des
signaux en phase
avec l’horloge.
q2
D Q
FF2
clk

tsu

clk

sig_async

q0
Parasite ignoré !

q1
q2

© D.Giacona
VHDL – Logique programmable 26/61 Partie 7 - Diagrammes d’état

3.3. Les erreurs dues à des événements extérieurs

Des événements extérieurs peuvent faire commuter les flip-flops intempestivement et


conduire la machine d’état dans un état ne figurant pas dans la séquence normale (lockup
states, illegal states).

 RÈGLE : Pour un registre d’états à n bits, il faut faire une analyse en tenant compte
des 2n états possibles

© D.Giacona
VHDL – Logique programmable 27/61 Partie 7 - Diagrammes d’état

3.4. Erreurs conduisant à des états inutilisés

 Machine à états décodés (one hot FSM) 00001

 5 états dans la séquence normale


 5 bits, donc 32 – 5 = 27 combinaisons hors séquence 10000
normale 00010

01000

00100

00001
00010
00100 Il faut sortir de cet
état pour rejoindre
00101 la séquence normale

Cette erreur peut être détectée (deux flip-flops sont à ‘1’), mais ajouter de la logique ne résout pas
forcément le problème, car cette logique supplémentaire est elle-même sensible aux perturbations
extérieures !

© D.Giacona
VHDL – Logique programmable 28/61 Partie 7 - Diagrammes d’état

3.4.1. Cas des machines comportant un code complet

 Machine à états codés (Gray)


 4 états dans la séquence normale
 2 bits, toutes les combinaisons sont utilisées

q1 <= ‘1’

00
Cette transition ne fait pas
partie de la séquence
normale, mais elle conduit
néanmoins à un état du cycle
01 10 normal.

11

Il n’existe aucun moyen pour détecter cette erreur !

© D.Giacona
VHDL – Logique programmable 29/61 Partie 7 - Diagrammes d’état

3.4.2. Méthodes de détection et de correction des erreurs

 Redondance
o Deux systèmes identiques traitent la entrée
même donnée. Si les sorties sont D Q
différentes, on réinitialise le système clk
o Trois systèmes, ou plus, traitent la même Vote à la
donnée. On effectue un vote à la majorité
majorité. D Q
(Comb.)
Exemple
Chaque flip-flop de la conception initiale
est remplacé par trois flip-flops (TMR : D Q
Triple Modular Redundancy)

 Parité Attention ! La méthode ne


o Détection des erreurs simples (un seul bit change d’état à la fois) protège pas des erreurs
pouvant survenir dans ce
bloc combinatoire
 Code de Hamming
o Détection des erreurs doubles et corrections des erreurs simples

© D.Giacona
VHDL – Logique programmable 30/61 Partie 7 - Diagrammes d’état

3.5. Les hasards statiques

Les chemins de routage des circuits FPGA engendrent des délais de propagation pour les
signaux. Ces délais peuvent provoquer des hasards statiques (glitches) à la sortie des blocs
combinatoires, c.-à-d. des états logiques momentanément incorrects.

Risque de glitch !!

Bloc combinatoire
Flip-flops

La sortie d’un bloc combinatoire…

 ne doit jamais être appliquée sur une entrée asynchrone


(clock, asynchronous clear, asynchronous preset,…)

 doit toujours être appliquée sur une entrée synchrone

© D.Giacona
VHDL – Logique programmable 31/61 Partie 7 - Diagrammes d’état

3.6. Les états internes transitoires

x <= ‘0’ ;
00 y <= ‘0’ ;

x <= ‘1’ ; x <= ‘0’ ;


01 y <= ‘0’ ; 11 y <= ‘1’ ;

10 x <= ‘1’ ;
y <= ‘1’ ;

 En théorie, le passage de l’état 01 à l’état 10 change l’état de deux bits simultanément.


 En pratique, il peut y avoir un décalage entre les changements d’état des deux flip-flops.
État transitoire

Les transitions suivantes sont possibles : 01  11  10 ou bien 01  00  10.

 Dans une machine de Moore à sorties combinatoires, x qui devrait rester à ‘1’, pourrait prendre
transitoirement une valeur fausse ‘0’.

© D.Giacona
VHDL – Logique programmable 32/61 Partie 7 - Diagrammes d’état

4. Le modèle diagramme/graphe d'état dans l’outil Active-HDL (Aldec)

4.1. Style de codage VHDL d’un diagramme d’états

 Tout diagramme d’état est traduit en code VHDL.


 Les éditeurs de diagramme proposent différents styles HDL.

© D.Giacona
VHDL – Logique programmable 33/61 Partie 7 - Diagrammes d’état

Organisation du code VHDL avec 3 processus concurrents :

------------------------------------
-- Next State Logic (combinatorial)
------------------------------------
Sreg0_NextState: process (…,…,…)

------------------------------------
-- Current State Logic (sequential)
------------------------------------
Sreg0_CurrentState: process (clk)

------------------------------------
-- Output Block
------------------------------------
Sreg0_OutputBlock: process (Sreg0)

© D.Giacona
VHDL – Logique programmable 34/61 Partie 7 - Diagrammes d’état

4.2. Les nœuds d’un graphe

4.2.1. Le cercle d'état

 Le cercle symbolise un état interne particulier de la machine à états.

 Dans un graphe d’état connexe, un seul état est actif à la fois ; il est aussi appelé
l’état courant.

 La description du comportement d'un système peut nécessiter plusieurs graphes


d'état (synchronisés entre eux ou indépendants)

© D.Giacona
VHDL – Logique programmable 35/61 Partie 7 - Diagrammes d’état

4.2.2. L'arc

L'arc, aussi appelé transition, indique la possibilité de passage d'un état à un autre.

© D.Giacona
VHDL – Logique programmable 36/61 Partie 7 - Diagrammes d’état

4.3. La dynamique d’un graphe

4.3.1. L’horloge

 L’horloge figure globalement par , mais jamais sur les arcs


 C’est toujours sur un front d’horloge (montant ou descendant) qu’un graphe peut
franchir une transition, c.-à-d. passer de l’état courant à l’état suivant/next_state
 Entre deux fronts d’horloge consécutifs, le graphe conserve son état interne

Sreg0_CurrentState: process (clk)


begin
if clk'event and clk = '1' then
Sreg0 <= NextState_Sreg0;
end if;
end process;

© D.Giacona
VHDL – Logique programmable 37/61 Partie 7 - Diagrammes d’état

4.3.2. La transition avec condition

 La condition de transition est une expression booléenne comprenant des signaux d'entrée
et/ou des signaux d'état internes ; elle participe à l’évolution du graphe

 L'état futur/next_state dépend à la fois


o de l'état courant/current_state
o et de la condition de transition associée à un arc sortant

 Ci-dessous, si init_LCD est l’état courant alors


o si la condition end_LCD_init = ‘1’ est vraie, alors au prochain front actif de
l'horloge, le nouvel état sera disp_zero
o sinon, il y a maintien dans l'état courant (représentation implicite)

© D.Giacona
VHDL – Logique programmable 38/61 Partie 7 - Diagrammes d’état

Code VHDL correspondant

Sreg0_NextState: process (end_LCD_init, Sreg0)


begin
NextState_Sreg0 <= Sreg0;
-- Set default values for outputs and signals
case Sreg0 is
when init_LCD =>
if end_LCD_init = '1' then
NextState_Sreg0 <= disp_zero;
end if;

© D.Giacona
VHDL – Logique programmable 39/61 Partie 7 - Diagrammes d’état

4.3.3. La transition directe (sans condition)

 Il n’y a aucune inscription sur l’arc.

 L’état disp_zero ne dure qu’une période d’horloge, puis l’état disp_zero_bis est
atteint.

case Sreg0 is
when init_LCD =>
if end_LCD_init = '1' then
NextState_Sreg0 <= disp_zero;
end if;
when disp_zero =>
NextState_Sreg0 <= disp_zero_bis;

© D.Giacona
VHDL – Logique programmable 40/61 Partie 7 - Diagrammes d’état

4.3.4. La priorité d’une transition

La priorité est pratique pour


simplifier les tests.
 Priorité 0 implicite
 Priorité 0 > 1 > 2 …

case Sreg0 is
when init_LCD =>
if end_LCD_init = '1' then
NextState_Sreg0 <= disp_zero;
end if;
when disp_zero =>
if a = '0' and b = '1' then
NextState_Sreg0 <= disp_zero_bis;
else
NextState_Sreg0 <= disp_zero_ter;
end if;

© D.Giacona
VHDL – Logique programmable 41/61 Partie 7 - Diagrammes d’état

5. Les paramètres des états d’un graphe

5.1. Le codage des états

-- GRAY ENCODED state machine: Sreg0


type Sreg0_type is (
init_LCD, disp_zero, disp_zero_bis, disp_zero_ter
);
signal Sreg0, NextState_Sreg0: Sreg0_type;

attribute enum_encoding: string;


attribute enum_encoding of Sreg0_type: type is
"00 " & -- init_LCD
"01 " & -- disp_zero
"11 " & -- disp_zero_bis
"10" ; -- disp_zero_ter

© D.Giacona
VHDL – Logique programmable 42/61 Partie 7 - Diagrammes d’état

5.2. L’état de repli d’un graphe

case Sreg0 is
when init_LCD =>
if end_LCD_init = '1' then
NextState_Sreg0 <= disp_zero;
end if;
when disp_zero =>
if a = '0' and b = '1' then
NextState_Sreg0 <= disp_zero_bis;
else
NextState_Sreg0 <= disp_zero_ter;
end if;
when others =>
-- trap state
NextState_Sreg0 <= init_LCD;

© D.Giacona
VHDL – Logique programmable 43/61 Partie 7 - Diagrammes d’état

5.3. L’état initial d’un graphe


Reset synchrone

------------------------------------
-- Current State Logic (sequential)
------------------------------------
Sreg0_CurrentState: process (clk)
begin
if clk'event and clk = '1' then
if rst = '1' then
Sreg0 <= init_LCD;
else
Sreg0 <= NextState_Sreg0;
end if;
end if;
end process;

© D.Giacona
VHDL – Logique programmable 44/61 Partie 7 - Diagrammes d’état

5.4. Les macro-états

© D.Giacona
VHDL – Logique programmable 45/61 Partie 7 - Diagrammes d’état

6. Les actions

 Une action est un ordre associé à un état ou à une transition ; elle permet
o d’assigner des valeurs ‘0’ ou ‘1’ à des ports de sortie ou d’appliquer des valeurs ‘0’
ou ‘1’ à des entrées enable | set | reset d’autres blocs,
o de décrire directement en VHDL des opérations complexes
 comptage, décomptage
 décalage droite, décalage gauche
 mémorisation
 opérations arithmétiques +, - , *

 Modes d’action
o action d’état (machine de Moore)
o action de transition (machine de Mealy)

 Modes d’assignation d’une sortie


o assignation par un bloc combinatoire
o assignation par un registre

© D.Giacona
VHDL – Logique programmable 46/61 Partie 7 - Diagrammes d’état

6.1. Actions concurrentes associées à l’ensemble d’un diagramme d’états

 Synchronisation des signaux d’entrée ; définition des signaux internes

Signaux internes de type registre.

© D.Giacona
VHDL – Logique programmable 47/61 Partie 7 - Diagrammes d’état

6.2. Action d’état – assignation combinatoire de la sortie

 Propriété de la sortie : type d’assignation et valeur par défaut

© D.Giacona
VHDL – Logique programmable 48/61 Partie 7 - Diagrammes d’état

Action d’état.

© D.Giacona
VHDL – Logique programmable 49/61 Partie 7 - Diagrammes d’état

------------------------------------
-- Output Block
------------------------------------
Sreg0_OutputBlock: process (Sreg0)
begin
x <= '0';
case Sreg0 is La sortie x est à ‘1’ tant que le signal la machine
when S2 => est dans l’état s2 (modèle de MOORE)
x <= '1';
when others =>
null;
end case;
end process;

 Simulation fonctionnelle

© D.Giacona
VHDL – Logique programmable 50/61 Partie 7 - Diagrammes d’état

6.3. Action de transition – assignation combinatoire de la sortie

Action de transition.

© D.Giacona
VHDL – Logique programmable 51/61 Partie 7 - Diagrammes d’état

------------------------------------
-- Output Block
------------------------------------
Sreg0_OutputBlock: process (a_syn, Sreg0)
begin
x <= '0'; La sortie x
case Sreg0 is  dépend de l’état interne de la machine et de
when S1 => l’entrée a_syn (modèle de MEALY)
if a_syn = '1' then  est à ‘0’ par défaut lorsqu’elle n’est pas assignée
x <= '1'; explicitement dans un état du graphe
end if;  est à ‘1’ tant que le signal a_syn est à ‘1’ et que
when others => la machine est dans l’état s1
null;
end case;
end process;

© D.Giacona
VHDL – Logique programmable 52/61 Partie 7 - Diagrammes d’état

 Simulation fonctionnelle

L’impulsion x est calibrée (une période d’horloge).

 Applications courantes des actions de transition


Comme le signal de sortie x n’est à ‘1’ que durant une période d’horloge, il peut servir de
signal de validation d’une opération séquentielle ponctuelle :
 Incrémenter ou décrémenter un compteur une seule fois, à un moment précis
 Décaler un registre à droite ou à gauche d’une seule position, à un moment précis
 Initialiser ou charger un registre

© D.Giacona
VHDL – Logique programmable 53/61 Partie 7 - Diagrammes d’état

6.4. Action d’état de comptage


Signaux internes de type registre.

Incrémentation implicite sur front Assignation combinatoire,


montant de clk. valeur par défaut ‘0’.

© D.Giacona
VHDL – Logique programmable 54/61 Partie 7 - Diagrammes d’état

-- diagram signals declarations


signal a_syn: STD_LOGIC;
signal count: STD_LOGIC_VECTOR (3 downto 0);

----------------------------
-- Diagram ACTION
----------------------------
sync_process : process(clk) begin
if clk'event and clk = '1' then
a_syn <= a;
end if;
end process;

© D.Giacona
VHDL – Logique programmable 55/61 Partie 7 - Diagrammes d’état

----------------------------------------------------------------------
-- Machine: Sreg0
----------------------------------------------------------------------
------------------------------------
-- Next State Logic (combinatorial)
------------------------------------
Sreg0_NextState: process (a_syn, count, Sreg0)
begin
NextState_Sreg0 <= Sreg0;
case Sreg0 is
when S1 =>
if a_syn = '0' then
NextState_Sreg0 <= S2;
end if;
when S2 =>
if a_syn = '1' then
NextState_Sreg0 <= S3;
end if;
when S3 =>
if count = "1001" then
NextState_Sreg0 <= S4;
end if;
when S4 =>
NextState_Sreg0 <= S1;
when others =>
null;
end case;
end process;

© D.Giacona
VHDL – Logique programmable 56/61 Partie 7 - Diagrammes d’état

------------------------------------
-- Output Block
------------------------------------
Sreg0_OutputBlock: process (count, Sreg0)
begin
-- Set default values for outputs and signals
next_count <= count;
x <= '0';
case Sreg0 is
when S1 =>
next_count <= "0000";
when S3 =>
next_count <= count + 1;
when S4 =>
x <= '1';
when others =>
null;
end case;
end process;

© D.Giacona
VHDL – Logique programmable 57/61 Partie 7 - Diagrammes d’état

------------------------------------
-- Current State Logic (sequential)
------------------------------------
Sreg0_CurrentState: process (clk)
begin
if clk'event and clk = '1' then
Sreg0 <= NextState_Sreg0;
end if;
end process;

------------------------------------
-- Registered Outputs Logic
------------------------------------
Sreg0_RegOutput: process (clk)
begin
if clk'event and clk = '1' then
count <= next_count;
end if;
end process;

© D.Giacona
VHDL – Logique programmable 58/61 Partie 7 - Diagrammes d’état

6.5. Une application pour carte Brevia 2 (Lattice)

Entrées
 clk : 50 MHz
 set : bouton poussoir sans rebond, produisant ‘0’
sur un appui
clk
Sorties
 leds_neg(3:0) : 4 leds (appliquer ‘0’ pour allumer)

Cahier des charges

 Réglage d’un chiffre (0123… 9012…),


affiché en code BCD sur les 4 leds.
 Un appui bref sur le bouton set (de durée inférieure
à 2 s) incrémente le chiffre une seule fois (+1). set
 Un appui long sur le bouton set (de durée supérieure
leds_neg(3:0)
ou égale à 2 s) incrémente automatiquement le
chiffre toutes les 500 ms tant que l’appui est maintenu.

© D.Giacona
VHDL – Logique programmable 59/61 Partie 7 - Diagrammes d’état

© D.Giacona
VHDL – Logique programmable 60/61 Partie 7 - Diagrammes d’état

Sorties à ‘0’ par défaut

© D.Giacona
VHDL – Logique programmable 61/61 Partie 7 - Diagrammes d’état

La simulation a été réalisée avec, respectivement, des durées de 500 ns et 2000 ns au lieu de 500 ms et 2000 ms.

© D.Giacona