Chap V:

Machine à états finis

FSM (Finite State Machine)

E. Amouri
 Machines à états

❑ Les machine à états finis sont couramment utilisées pour

modéliser des séquenceurs ou des blocs de contrôle.

❑ Une machine à états finis est un circuit séquentiel dont les

sorties dépendent d’un état et éventuellement des entrées.

2
 Machines à états

❑ Notations :
❑ Entrée : E
❑ Etat Présent : EP
❑ Etat Futur : EF
❑ Sortie : S

❑ Définitions
❑ Etat : Indicateur de position dans le temps
❑ Registre d’Etat : Composé de bascules permettant de mémoriser les
valeurs des états
❑ Etat Présent : état de la machine à l’instant présent
❑ Etat Futur : état dans lequel se trouvera la machine après une impulsion

3
 Machines à états

❑ Table de transition:
❑ E : Entrée à l’instant n
❑ EP : Etat Présent à l’instant n
❑ EF : Etat Suivant à l’instant n + 1
❑ S : Fonction de Sortie à l’instant n

❑ Table de transition :

4
 Machines à états

❑ Graphe d’état:
❑ 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.

5
Notations Transitions

❑ Les cercles représentent les

états et les flèches représentent
les transitions entre les états.

❑ La transition d’un état à l’autre

est synchronisée sur le front
d’un signal d’horloge.

6
 Transitions

❑ Il existe deux types de transitions :

❑ Les transitions conditionnelles : elles ne s’effectuent qu’en fonction

d’une certaine valeur du vecteur d’entrée et sur le front
d’horloge. Il y a au moins deux transitions conditionnelle qui
partent d’un même état.

❑ Les transitions inconditionnelles : elles s’effectuent

automatiquement sur le front d’horloge. Il ne peut y avoir qu’une
seule transition qui parte d’un état lorsque celle-ci est
inconditionnelle.

7
 Etat d’initialisation

❑ Dans le graphe, l’état d’initialisation représente l’état dans lequel se retrouve le

système après un RESET ASYNCHRONE

❑ Les transitions d’un état vers l’état initial par suite d’un RESET ASYNCHRONE ne
sont pas explicitées dans le graphe

❑ SEULES les TRANSITIONS SYNCHRONES (sur un front d’horloge) sont représentées

dans le graphe d’état

8
 Les machines à états

❑ Machine de Moore
❑ les signaux de sortie ne dépendent que de l’état courant

❑ machine de Mealy:
❑ les signaux de sortie dépendent de l’état et des signaux
d’entrée.

❑ Utilisation d’au moins 2 process :

❑ Un process de transition de l’état futur à l’état présent.
❑ Un process de détermination des sorties et de l’état futur.

9
 Graphe de Transition d’une machine Moore

❑ Entrées: rst, clk, X2X1X0

❑ Reset asynchrone, actif à

l’état haut

❑ Sorties : Z2Z1Z0

10
 Les machines à états en VHDL

❑ Utilisation de 3 process :
❑ Un process séquentiel de transition de l’état futur à l’état
présent.
❑ Un process de détermination des sorties
❑ Un process de détermination de l’état futur.

11
 Machines de Moore - 3 process – entité

library ieee;
use ieee.std_logic_1164.all;

entity fsm is
port (
clk, rst : in std_logic; -- horloge, reset
x : in std_logic_vector(2 downto 0); -- entrées
z : out std_logic_vector(2 downto 0) -- sorties
);
end fsm;

12
 Machine de Moore - 3 process – Architecture

Architecture moore_3proc of fsm is

type fsm_states is (S0, S1, S2); OutputState: process (Etat_Present)
signal Etat_Present, Etat_Futur: Begin
fsm_states; ----
begin end process OutputState;

Clocked : process (rst, clk) end Architecture moore_3proc;

Begin
-----
end process Clocked ;

NextState: process (Etat_Present, x)

Begin
----
end process NextState;
13
Machine de Moore - 3 process – Architecture

Clocked : process (rst, clk) NextState: process (Etat_Present, x)

Begin Begin
if (rst = '1‘) then case Etat_Present is
Etat_Present <= S0;
when S0 =>
elsif (clk'event and clk = '1) then
Etat_Present <= Etat_Futur;
if x(2) = ’1’ then Etat_Futur <= S0;
end if; else Etat_Futur <= S1;
end process Clocked ; end if;
when S1 =>
OutputState: process (Etat_Present) if x(0) = ’0’ then Etat_Futur <= S2;
Begin else Etat_Futur <= S0;
case Etat_Present is end if;
when S0 => z <= "110"; when S2 =>
when S1 => z <= "011"; Etat_Futur <= S0;
when S2 => z <= "000"; when others => Etat_Futur <= S0;
when others => z <= "xxx";
end case;
end case;
end process OutputState;
end process NextState;
14
 Les machines à états en VHDL

❑ Utilisation de 2 process :

❑ Un process séquentiel de transition de l’état futur à l’état présent.

❑ Un process de détermination des sorties et l’état futur

15
Machine de Moore - 2 process – Architecture
Clocked : process (rst, clk)
Begin
if (rst = '1‘) then
Etat_Present <= S0;
elsif (clk'event and clk = '1) then
Etat_Present <= Etat_Futur;
end if;
end process Clocked ;
NextState: process (Etat_Present, x)
Begin
case Etat_Present is
when S0 => z <= "110";
if x(2) = ’1’ then Etat_Futur <= S0;
else Etat_Futur <= S1;
end if;
when S1 => z <= "011";
if x(0) = ’0’ then Etat_Futur <= S2;
else Etat_Futur <= S0;
end if;
when S2 => z <= "000";
Etat_Futur <= S0;
when others => z <= "xxx";
Etat_Futur <= S0;
end case;
end process NextState; 16
 Graphe de Transition d’une machine de
Mealy

❑ Entrées: rst, clk, X2X1X0

❑ Sorties : Z2Z1Z0

17
 Machine de Mealy - 2 process - Entité

library ieee;
use ieee.std_logic_1164.all;

entity fsm is
port (
clk, rst : in std_logic; -- horloge, reset
x : in std_logic_vector(2 downto 0); -- entrées
z : out std_logic_vector(2 downto 0) -- sorties
);
end fsm;

18
Machine de Mealy - 2 process - Architecture

Architecture mealy_2proc of fsm is

type fsm_states is (S0, S1, S2);
signal Etat_Present, Etat_Futur : fsm_states;
begin

Clocked : process (rst, clk)

Begin
if (rst = '1‘) then
Etat_Present <= S0;
elsif (clk'event and clk = '1‘) then
Etat_Present <= Etat_Futur;
end if;
end process Clocked ;

19
 Machine de Mealy - 2 process - Architecture

NextState: process (Etat_Present, x)

Begin
case Etat_Present is
when S0 => if x(2) = ‘1 when S2 => z <= "110";
then z <= "110"; Etat_Futur <= S0;
Etat_Futur <= S0;
else z <= "011"; when others => z <= "xxx";
Etat_Futur <= S1; Etat_Futur <= S0;
end if; end case;
when S1 => if x(0) = '1’ end process NextState;
then then z <= "110"; end Architecture mealy_2proc;
Etat_Futur <= S0;
else z <= "000";
Etat_Futur <= S2;
end if;

20
 l’horloge : entrée implicite

❑ Horloge = entrée toujours présente

❑ Machine à état synchrone

❑ Le changement d’état s’effectue sur un front d’horloge.

21
 FSM-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)
❑ Etat 1 : le système attend un ‘2’ en entrée, la porte est fermée (P=0)
❑ Etat 2 : le système attend un ‘3’ en entrée, la porte est fermée (P=0)
❑ Etat 3 : la bonne séquence a été entrée, la porte est ouverte (P=1)

22
 Exemple: détecteur de séquence
❑ Machine de Moore

23
 Exemple: détecteur de séquence
❑ Machine de Mealy

24
 Exercice: Distributeur de boisson

❑ Un distributeur de boissons vend les boissons pour 5$. L’usager a le droit de

mettre des pièces de 1$ ou de 2$.
❑ dès que le montant arrive a 5$ ou plus, il y a une boisson qui sort.
❑ Il est aussi possible que l’usager mette 6$ et dans ce cas, la machine donne une
boisson et remet aussi la monnaie.

25
 Exercice: Distributeur de boisson

❑ déterminer les entrées et sorties.

❑ Puisque c’est une machine à états, il doit y avoir une horloge.
❑ On peut soit insérer 1$, 2$ ou rien, donc on va avoir une entrée pour chaque
type de monnaie.
❑ A la sortie, on peut soit donner une boisson ou soit donner une boisson et de la
monnaie.

26
Exercice: Distributeur de boisson
Graphe de Transition

27
 Exercice: Distributeur de boisson

Library IEEE ;
Use ieee.std_logic_1164.all;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY machine IS
PORT (
clk : IN STD_LOGIC;
un_dollar : IN STD_LOGIC;
deux_dollars : IN STD_LOGIC;
boisson : OUT STD_LOGIC;
monnaie : OUT STD_LOGIC
);
END entity machine;
28
 Exercice: Distributeur de boisson
ARCHITECTURE RTL OF machine IS WHEN
TYPE etats IS (zero, un , deux, trois, quatre,
cinq, six);

SIGNAL etat_present , etat_prochain : etats;

BEGIN

PROCESS ( )

BEGIN
CASE etat_present IS WHEN
WHEN

29
 Exercice: Distributeur de boisson
WHEN WHEN

WHEN

END PROCESS;
WHEN

PROCESS ( )
BEGIN

END PRCESS;

END architecture RTL;

30
 Exercice: Arbitre gérant l'accès à une ressource
partagée

◼ L'arbitre reçoit les signaux REQ_1 et REQ_2 en provenance de 2 demandeurs

(le demandeur 1 est considéré plus prioritaire que le demandeur 2).

◼ Le signal BSY est une entrée que reçoit l'arbitre. Ce signal est activé si l'un des
demandeurs, ayant reçu un acquittement de la part de l'arbitre, est en train de
traiter la donnée partagée.

◼ Selon l'état du signal BSY, l'arbitre active vers le demandeur sélectionné le signal
RETRY (ressource occupée, BSY = 1), ou ACK (ressource libre, BSY =0). Le signal
RETRY est maintenu tant que la demande REQ est présente et tant que la
ressource est occupée.

◼ Le signal ACK est maintenu tant que la demande REQ est présente.
La machine d'état est synchrone, rythmée par le signal d'horloge CLK.
◼ Enfin, le signal RESET (actif à l'état haut), permet une remise à zéro asynchrone.31
Exercice: Arbitre gérant l'accès à une ressource
partagée: Graphe de transition

32
 Exercice: Arbitre gérant l'accès à une ressource
partagée

Library IEEE ;
Use ieee.std_logic_1164.all;

Entity Arbitre is port (

End arbitre;

33
 Exercice: Arbitre gérant l'accès à une ressource
partagée

Architecture FSM of Arbitre is

begin

Clocked : process (rst, clk)

Begin

end process Clocked ;

34
 Exercice: Arbitre gérant l'accès à une ressource
partagée
Process ( )
Begin

35
Exercice: Arbitre gérant l'accès à une ressource
partagée

End Architecture FSM;

36