Vous êtes sur la page 1sur 16

Machines d’état

Les machines d’états permettent d’effectuer la synthèse de systèmes numériques séquentiels,


généralement synchrones (mais la synthèse de systèmes asynchrones est possible) à partir d’un
cahier des charges.
Quelques exemples vont permettre de nous familiariser avec cette notion.

Exemple 1 : moteur pas à pas à sens de rotation unique.

Synthétisons dans ce premier exemple le séquenceur destiné à la commande d’un moteur pas à pas,
unipolaire 4 phases, à un seul sens de rotation, en fonctionnement pas entier deux phases (voir le
principe de fonctionnement d’un tel moteur en annexe).
Nous avons ci-après les signaux recherchés S0, S1, S2 et S3 pour la commande des phases en
fonction de l’horloge H :

On note 4 états possibles en sortie, s’enchaînant inconditionnellement dans l’ordre E1, E2, E3, E4,
E1…au rythme de l’horloge H.

A partir de ce cahier des charges, on peut en déduire le diagramme (ou diagramme à bulles) suivant ;

nom
E1 E2
de
l'état 1001 1010

valeur
E4 E3
des
sorties 0101 0110

Ce diagramme représente les différents états du système, en précisant éventuellement les niveaux
logiques correspondants en sortie, et les conditions de passage d’un état à l’autre. Dans notre cas
très simple, à chaque coup d’horloge, on passe inconditionnellement à l’état suivant.

La machine doit toujours se trouver au moins dans un état, et dans un seul état.

Avant l’apparition des langages HDL (Hardware circuits Description Language) de programmation, la
synthèse d’une machine d’état impliquait la recherche des équations des entrées des bascules de

Denis Rabasté 1/16 IUFM Aix Marseille


machines d’état

mémorisation des états. Aujourd’hui, il est possible de retranscrire directement le diagramme d’état en
programme ; voici par exemple, un fichier VHLD associé à ce diagramme :
library ieee;
use ieee.std_logic_1164.all;

entity CDE_MOT_2 is
port( H : in std_logic;
SORTIES : out std_logic_vector (3 downto 0));
end CDE_MOT_2;

architecture ARC_CDE OF CDE_MOT_2 is


type TYPE_ETAT is (E1, E2, E3, E4);
signal X:TYPE_ETAT;
begin
process (H)
begin
if H'event and H = '1' then
case X is
when E1 => X <= E2;
when E2 => X <= E3;
when E3 => X <= E4;
when others => X <= E1;
end case;
end if;
end process;

with X select
SORTIES <= "1001" when E1,
"1010" when E2,
"0110" when E3,
"0101" when E4;

end ARC_CDE;

L’architecture du programme comprend deux parties distincts : l’instruction « process » gère le


passage d’un état au suivant à chaque coup d’horloge, tandis l’instruction « with select » affecte aux
sorties les valeurs correspondant à chaque état.

Remarques : le programme aurait pu être simplifié ( et les ressources du circuit cible économisées) en
remarquant que les sorties étaient complémentaires deux à deux.

On notera que tous les états possibles des sorties n’ont pas été traités dans le diagramme d’état, afin
de ne pas l’alourdir. Dans la description VHDL cependant, les états imprévus conduisent à l’état E1
(instruction « when others ») au coup d’horloge suivant. Cette solution n’est pas toujours la plus
intéressante, un état imprévu conduisant alors à un fonctionnement aléatoire difficile à détecter et à
supprimer ; il est parfois préférable d’avoir une panne franche, en prévoyant par exemple un état
« Erreur ».

Exemple 2 : moteur pas à pas à double sens de rotation.

Reprenons le premier exemple en introduisant cette fois une commande S permettant de choisir le
sens de rotation. Nous supposerons cette commande synchrone dans un premier temps.

Les chronogrammes recherchés sont alors :

Denis Rabasté 2/16 IUFM Aix Marseille


machines d’état

Ce qui nous conduit au diagramme d’état suivant :


S
E1 E2
1001 1010

S
S S S S
S
E4 E3
0101 0110

Remarques :
- lorsque plusieurs entrées interviennent dans un diagramme d’état, on suppose qu’une seule
est susceptible de changer à un instant donné ;
- lorsque les conditions ne sont pas réalisées, l’état ne change pas (dans notre exemple, les
conditions étant complémentaires, elles sont toujours réalisées) ;
- lorsque plusieurs branchements sont possibles à partir d’un état, les conditions ne doivent pas
être vraies en même temps ;
- la présence de l’horloge est implicite, le passage d’un état à l’autre ne peut se faire qu’au front
actif de l’horloge.

Une description VHDL possible est alors donnée ci-après :

library ieee;
use ieee.std_logic_1164.all;

entity CDE_MOT_2S is
port( H,S : in std_logic;
SORTIES : out std_logic_vector (3 downto 0));
end CDE_MOT_2S;

architecture ARC_CDE OF CDE_MOT_2S is


type TYPE_ETAT is (E1, E2, E3, E4);
signal X:TYPE_ETAT;
begin
process (H)
begin
if H'event and H = '1' then
case X is
when E1 =>
if S='1' then X <= E2;
else X <=E4;
end if;

Denis Rabasté 3/16 IUFM Aix Marseille


machines d’état

when E2 =>
if S='1' then X <= E3;
else X <=E1;
end if;

when E3 =>
if S='1' then X <= E4;
else X <=E2;
end if;

when others =>


if S='1' then X <= E1;
else X <=E3;
end if;

end case;
end if;
end process;

with X select
SORTIES <= "1001" when E1,
"1010" when E2,
"0110" when E3,
"0101" when E4;

end ARC_CDE;

Machine de Moore
Le fonctionnement décrit précédemment correspond à celui d’une machine dite de Moore dont le
schéma est donné ci-après :
horloge

couche
combinatoire couche
état état
entrées combinatoire sorties
futur registre actuel
calcul d'état
de l'état calcul
futur des
sorties

Avec ce type de machine, un registre d’état (composé de bascules) mémorise l’état actuel, tandis
qu’une couche combinatoire positionne l’entrée du registre afin de pouvoir activer l’état suivant au
coup d’horloge suivant.

Les sorties sont déterminées par une couche combinatoire en fonction des sorties du registre d’état.
Elles sont donc synchrones avec l’horloge.

Les performances du système vont beaucoup dépendre de la simplicité ou de la complexité des


couches combinatoires. Plusieurs stratégies sont possibles :
- affecter une sortie du système à chaque sortie du registre d’état (état codé avec les sorties),
ce qui n’est pas toujours possible ; la couche combinatoire de calcul des sorties est alors
supprimée, le temps entre le front d’horloge et l’évolution des sorties est optimal ;

Denis Rabasté 4/16 IUFM Aix Marseille


machines d’état

- affecter une bascule par état dans le registre d’état (« one hot »), le nombre de bascules est
alors généralement important, mais le décodage des sorties et surtout le calcul de l’état futur
est facilité, permettant une fréquence de fonctionnement élevée ;
- minimiser le nombre de bascules (codage binaire) ; N bascules pouvant coder 2N états ; les
couches combinatoires sont alors complexes et le système lent.

La solution choisie dépend de la manière dont va être écrit le programme.


Machine de Mealy
Dans certains cas, on peut souhaiter des sorties fonctionnant de manière asynchrones, la structure
est alors modifiée pour conduire à une machine de type Mealy :

horloge

couche
combinatoire couche
état état
entrées combinatoire sorties
futur registre actuel
calcul d'état
de l'état calcul
futur des
sorties

On modifie parfois le diagramme d’état de ce type de machine en précisant la valeur des sorties (0101
puis 1001 dans l’exemple) non plus dans la bulle d’état, mais dans la transition (ou vergent) avec la
condition de passage (A puis B dans l’exemple).
A
0101
EX

B
1001

On pourrait par exemple souhaiter une ré-initialisation asynchrone vers la valeur « 1001 » des sorties
des phases de notre moteur par une entrée RINIT (l’entrée de sens à été supprimée afin de simplifier).

RINIT
RINIT 1010
1001 E1 E2

1 RINIT RINIT
1001 1001 0110

RINIT
E4
1001
E3

RINIT
0101

Les sorties ne dépendent plus cette fois de l’état actif, mais également de l’entrée RINIT.

Une réalisation possible étant donnée par le programme ci-après :

Denis Rabasté 5/16 IUFM Aix Marseille


machines d’état

library ieee;
use ieee.std_logic_1164.all;

entity CDE_MOT_M4 is
port( H, RINIT: in std_logic;
SORTIES : out std_logic_vector (3 downto 0));
end CDE_MOT_M4;

architecture ARC_CDE OF CDE_MOT_M4 is


type TYPE_ETAT is ( E1, E2, E3, E4);
signal X:TYPE_ETAT;
begin
process (H)
begin
if H'event and H = '1' then
case X is
when E1 => if RINIT='1' then X <= E1;
else X <= E2;
end if;

when E2 => if RINIT='1' then X <= E1;


else X <= E3;
end if;

when E3 => if RINIT='1' then X <= E1;


else X <= E4;
end if;

when others => X <= E1;


end case;
end if;
end process;

SORTIES <= "1010" when (X=E1 and RINIT='0') else


"0110" when (X=E2 and RINIT='0') else
"0101" when (X=E3 and RINIT='0') else
"1001";

end ARC_CDE;

Sur les chronogrammes suivant, on note bien le caractère asynchrone des changements de valeurs
en sortie lors de l’initialisation, avec des changements d’état qui restent par contre synchrones de
l’horloge.

Denis Rabasté 6/16 IUFM Aix Marseille


machines d’état

Exemple 3 : diviseur de fréquence.

Le nombre d’états d’un système n’est pas lié au nombre d’états possibles des sorties.
Considérons par exemple un diviseur de fréquence fournissant une impulsion en sortie toutes les
quatre impulsions du signal d’horloge.

Pour synthétiser un tel diviseur, il ne suffit évidemment pas de prendre en compte les deux états
possibles de la sortie, mais tous les états intermédiaires du système.

E1 E2
0 0

E4 E3
1 0

Un exemple de programme est donné ci-après :

library ieee;
use ieee.std_logic_1164.all;

entity div4 is
port( H : in std_logic;
S : out std_logic);
end div4;

architecture ARC_div OF div4 is


type TYPE_ETAT is (E1, E2, E3, E4);
signal X:TYPE_ETAT;
begin
process (H)
begin
if H'event and H = '1' then
case X is
when E1 => X <= E2;
when E2 => X <= E3;
when E3 => X <= E4;
when others => X <= E1;
end case;
end if;
end process;

S <= '1' when X=E4 else '0';


end ARC_div;

Denis Rabasté 7/16 IUFM Aix Marseille


machines d’état

Exemple 4 : comparateur 3 états d’une boucle à verrouillage de


phase.

Cet exemple met en évidence la possibilité d’utiliser les machines d’état afin de synthétiser un
système asynchrone, ici le comparateur 3 états d’une boucle à verrouillage de phase semi-numérique.
Nous nous contenterons d’étudier le diagramme d’état, la transcription en VHDL étant fastidieuse.

Les chronogrammes suivants rappellent le fonctionnement :si les fronts des signaux d’entrée arrivent
en même temps, la sortie PC2OUT du comparateur reste en haute impédance (pas de changement à
l’entrée de l’OCT), si le front montant du signal référence SIGNIN arrive en premier, la sortie passe au
niveau logique 1 jusqu’à l’arrivée du front montant du signal de contre réaction COMPIN
(augmentation de la tension d’entrée de l’OCT), la sortie passant à 0 entre les deux fronts si le signal
de contre réaction est en avance.

Le constructeur donne alors le diagramme d’état suivant :

On notera que le constructeur s’est autorisé quelques liberté avec le formalisme habituel des
diagrammes d’état. Les états hachurés correspondent à une sortie en haute impédance, les états
blancs de gauche à un niveau logique 1 en sortie, ceux de droite à un niveau logique 0. Les
changements d’état sont provoqués par les fronts montant des signaux S (SIGNIN) et C (COMPIN).

Denis Rabasté 8/16 IUFM Aix Marseille


machines d’état

Description d’une machine d’état à l’aide de l’utilitaire de Quartus

Le logiciel Quartus nous permet de décrire directement graphiquement notre fonctionnement par une
machine d’état.
Il est cependant important de comprendre qu’il ne s’agit que d’une aide, dont le but est de générer un
fichier HDL (Hardware Description Language), par exemple en VHDL, fichier qui servira de base de
départ aux différentes simulations et compilations.

La syntaxe générée par l’éditeur de machine d’état de Quartus est un peu différente de celle que nous
avons étudiée précédemment, le programme suivant correspondant à notre première description
d’une commande de moteur pas à pas à un seul sens de rotation :

LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY ME IS
PORT ( clock : IN STD_LOGIC;
reset : IN STD_LOGIC := '0';
SORTIES : OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
END ME;

ARCHITECTURE BEHAVIOR OF ME IS
TYPE type_fstate IS (ETAT1,ETAT2,ETAT3,ETAT4);
SIGNAL fstate : type_fstate;
SIGNAL reg_fstate : type_fstate;

BEGIN
PROCESS (clock,reg_fstate)
BEGIN
IF (clock='1' AND clock'event) THEN fstate <= reg_fstate;
END IF;
END PROCESS;

PROCESS (fstate,reset)
BEGIN
IF (reset='1') THEN reg_fstate <= ETAT1; SORTIES <= "0000";
ELSE SORTIES <= "0000";
CASE fstate IS
WHEN ETAT1 =>
reg_fstate <= ETAT2; SORTIES <= "0001";
WHEN ETAT2 =>
reg_fstate <= ETAT3; SORTIES <= "0010";
WHEN ETAT3 =>
reg_fstate <= ETAT4; SORTIES <= "0100";
WHEN ETAT4 =>
reg_fstate <= ETAT1; SORTIES <= "1000";
WHEN OTHERS =>
SORTIES <= "XXXX";
report "Reach undefined state";
END CASE;
END IF;
END PROCESS;
END BEHAVIOR;

On notera la déclaration de deux registre d’état, le premier « fstate » mémorisant l’état présent, le
second « reg_fstate » mémorisant l’état futur en fonction d’éventuelles entrées. L’état futur devient
l’état présent à chaque coup d’horloge dans le premier « process ».
Exemple d’utilisation
Reprenons la commande d’un moteur pas à pas, de quatre phases unipolaire décrit en annexe.
Nous allons synthétiser une machine d’état proposant ces deux modes de fonctionnement pour les
deux sens de rotation, en fonction de deux entrées :
- S pour le sens ;
- P pour un fonctionnement pas entier une phase ou demi-pas.

Si P est au NL1 on passe par tous les états 1, 2, 3, 4, 5, 6, 7, 8, 1… dans cet ordre ou l’inverse suivant
la valeur de S.
Denis Rabasté 9/16 IUFM Aix Marseille
machines d’état

Si P est au NL0, seuls les états pairs seront actifs, dans l’ordre 2, 4, 6, 8, 2… ou l’inverse suivant la
valeur de S.

On pourrait imaginer aussi une entrée proposant un mode demi-pas deux phases, où seuls les états
impairs seraient actifs.

Après avoir ouvert un projet par les méthodes habituelles, ouvrir une feuille de description de machine
d’état par « file » « new » puis « States Machine File » :

Il est alors possible de décrire notre machine, soit directement sur la feuille à partir des outils
proposés, soit à l’aide de l’assistant « State Machine Wizard » de la barre d’outils, comme nous
allons le faire :

L’assistant propose, soit de créer une nouvelle machine (notre option pour l’instant), soit d’en modifier
une existante ; il sera en effet toujours possible de modifier notre description, soit à l’aide de
l’assistant, soit par les outils classiques.

Denis Rabasté 10/16 IUFM Aix Marseille


machines d’état

Préciser ensuite que l’on souhaite une machine synchrone, avec une réinitialisation active à l’état bas
(l’appui sur les boutons poussoirs de la carte DE2 provoque un NL0) et des sorties mémorisées dans
un registre.

Dans la fenêtre suivant, commencer par déclarer tous les états possibles de E1 à E8 (pour déclarer un
nouvel état, faire un double clic dans la case correspondante) :

Déclarer ensuite les ports d’entrée (par défaut « clock » et « reset » existent déjà), puis les transitions
permettant de passer d’un état à l’autre.

Règles de syntaxes :
- un bus de N bits en entrée ou en sortie peut être déclaré par « Bus[N-1 :0] » ;
- dans les transitions les opérations logiques s’écrivent :
o ~ pour le NON (Alt Gr 2) ;
o & pour le ET ;
o | pour le OU (Alt Gr 6) ;
o ^ pour le OU EXCLUSIF ;
- la valeur d’un bus est par défaut en décimal, mais peut s’écrire en binaire par « ‘b00111001 »
par exemple ou en hexadécimal par « ‘h3A » par exemple ;
- les conditions de transition peuvent être des comparaisons :
o == pour égal ;
o != pour différent ;
o > pour supérieur ;
o < pour inférieur ;
o >= pour supérieur ou égal ;
o <= pour inférieur ou égal.

Entrer ensuite les différentes transitions pour passer d’un état à l’autre (il est conseillé, vu la syntaxe
un peu lourde, d’utiliser le « copier coller ») :

L’étape suivante consiste à déclarer les sorties et préciser leurs valeurs pour chaque état :

Denis Rabasté 11/16 IUFM Aix Marseille


machines d’état

Nous déclarerons une sortie destinée à commander les phases du moteur « PH[3 :0] » et une
permettant éventuellement de visualiser sur la carte DE2 l’état actif (sous réserve de l’afficher via un
décodeur sur un des afficheurs 7 segments par exemples, et sous réserve que l’horloge soit
suffisamment lente pour permettre une lecture).

La dernière page récapitule les états, les entrées et les sorties.

Le diagramme d’état résultant s’affiche alors (il est parfois nécessaire d’arranger un peu l’agencement
des états et transitions pour avoir un schéma lisible) :

On peut noter une flèche pointant vers l’état E1, indiquant que la remise à 0 de la machine rendra cet
état actif par défaut, car c’est le premier que nous avons déclaré. Si cette situation ne convient pas, il
est possible de modifier par l’onglet « States » de la zone « State Table » (la faire éventuellement
apparaître avec l’outil approprié de la barre d’outils).

Denis Rabasté 12/16 IUFM Aix Marseille


machines d’état

Comme indiqué au début, il est possible de modifier à loisir la machine d’état, soit en utilisant la barre
d’outils, soit en ouvrant de nouveau l’assistant :

Une fois le résultat satisfaisant, il est ensuite nécessaire de générer le fichier HDL pour programmer le
circuit, en précisant que l’on souhaite une description VHDL :

Le fichier VHDL s’ouvre alors ; il est parfois nécessaire de le vérifier. Dans notre cas par exemple,
l’action du « reset » a pour effet de mettre la machine dans l’état E1 comme convenu, mais également
de mettre tous les bits des bus PH[3 :0] et ETAT[3 :0] au NL0.

Denis Rabasté 13/16 IUFM Aix Marseille


machines d’état

Il est possible de modifier le programme à volonté, pour changer la valeur des sorties lors de
l’initialisation par exemple :

BEGIN
IF (reset='0') THEN
reg_fstate <= E1;
reg_PH <= "0101";
reg_ETAT <= "0001";
ELSE
reg_PH <= "0101";
reg_ETAT <= "0001";
CASE fstate IS
WHEN E1 =>

Il sera maintenant nécessaire d’effectuer les opérations habituelles sur ce type de projet (vérification,
simulation, génération de symbole, compilation etc…) pour finaliser le projet.

Remarque importante :
La machine d’état est incrémentée par une horloge « clock » qui doit être de fréquence faible
(quelques kHz maximum) pour commander un moteur pas à pas.
Si on utilise la carte DE2 avec ses horloges à 27 et 50 MHz, il sera nécessaire d’implanter un diviseur
de fréquence.
Il est impératif, pour que le système reste synchrone et ne génère pas systématiquement des états
aléatoires, d’ajouter une entrée de validation d’horloge « C_EN » par exemple. Le diviseur fera passer
C_EN au NL1 tous les N coups de l’horloge principale (si on souhaite un pas par secondes avec
l’horloge à 50 MHz, alors N vaudra 50 millions).
Il suffit alors d’ajouter « & C_EN » à toutes les conditions de transition de notre machine d’état pour
obtenir un fonctionnement correct.

Bibliographie

Electronique numérique et séquentielle par N. Richard chez Dunod

Logique programmable par L. Dutrieux et D. Demigny chez Eyrolles

Modélisation de systèmes intégrés numériques par A. Vachoux sur :


http://lsmwww.epfl.ch/Site01OCT10/Courses/modelnum01.book.pdf

Denis Rabasté 14/16 IUFM Aix Marseille


machines d’état

Annexe : principe de fonctionnement du moteur pas à pas

Un moteur pas à pas peut être schématiquement représenté par la figure suivante :

Il peut fonctionner en mode pas entier une phase : une seule phase est alimentée à la fois, comme
l’indique la figure suivante :

Les chronogrammes et la machine d’état associés sont représentés ci-après :

Mais il peut aussi fonctionner en mode demi-pas, ou on alimente alternativement une phase, puis
deux, permettant ainsi de doubler le nombre de pas par tour :

Denis Rabasté 15/16 IUFM Aix Marseille


machines d’état

On peut également envisager un mode pas entier 2 phases alimentés, ce qui revient à fonctionner
dans les états impairs 1, 3, 5, 7, 1…. : le nombre de pas est identique au mode pas entier 1 phase
alimentée, mais le couple moteur est augmenté par l’alimentation de deux bobines simultanément
(d’un rapport 2 dans notre exemple simple).
Pour commander un moteur 2 phases bipolaires au lieu d’un 4 phases unipolaires, il suffit d’associer
la phase A du moteur unipolaire au passage d’un courant positif dans la première bobine du moteur
bipolaire, et la phase B à celui d’un courant négatif dans cette même bobine (même raisonnement
avec les phase C et D et la seconde bobine) comme lors de l’association des circuits L297 et L298,
dont un extrait de la documentation est reproduit ci-après.

Denis Rabasté 16/16 IUFM Aix Marseille