Créer un site internet

Logique séquentielle synchrone, bascules

ENI: Électronique Numérique Intégrée

pélever du site www.comelec.enst.fr pour tout droit
--- 

Chapitre 7
Machines à états

7.1 Introduction

Les machines à états sont des circuits de logique séquentielle (cf chapitre 6) servant exclusivement à générer des signaux de commande. Il existe en effet 2 grands types de signaux en électronique :

  • Signaux à traiter : les données
  • Signaux pilotant le traitement : les commandes

Cette classification des signaux se retrouve au niveau des architectures des systèmes électroniques qu’on peut schématiser comme dans la figure 7.1 où la partie contrôle, générant les commandes, est dissociée de la partie opérative, traitant les données. Les 2 parties sont toujours réalisées en logique séquentielle et dans un très grande majorité des cas en logique séquentielle synchrone.

PIC

Fig. 7.1: Architecture générique d’un circuit électronique

Pour la logique séquentielle synchrone, il existe 2 signaux de commandes importants :

  • L’horloge : pour le déroulement des séquences
  • Le Reset : pour l’initialisation du système

La machine à état représente la partie contrôle, c’est à dire le cerveau du système électronique et la partie opérative , les jambes.

Il existe beaucoup de déclinaisons de cette architecture, des plus compliquées comme les microprocesseurs qui ont plusieurs machines à états et plusieurs parties opératives, des plus simples mais tout aussi importantes comme les contrôleurs d’ascenseurs ou de machine à café. Pour ce dernier type de système, les données sont inexistantes car les commandes servent à piloter des actionneurs, valves et moteurs,...

Les états de la machine à états représentent toutes les valeurs que peuvent prendre les variables internes du circuit de logique séquentielle (cf chapitre 6). Le schéma de la machine à états générique est représenté en figure 7.2

PIC

Fig. 7.2: Schéma d’un machine à état générique

Par exemple pour la machine à café, les états peuvent être :

  1. Attente de pièce
  2. Descendre le gobelet
  3. Verser la poudre de café
  4. Verser l’eau chaude
  5. Indiquer que c’est prêt

Cette machine peut se compliquer en prenant en compte : le choix de la boisson, le dosage du sucre, mais elle reste néanmoins très simple par rapport à certaines machines à états industrielles comme la conduite d’une centrale nucléaire, ou l’automatisation d’un usine de production. D’autres types de machines à états ont des contraintes de performances très grandes, c’est la cas de celles utilisées dans les microprocesseurs ou des processeurs spécialisées pour le graphisme ou les télécommunications.

PIC PIC PIC PIC PIC

Fig. 7.3: Où rencontrer les machines à états

Un circuit de logique séquentielle sur les données n’est pas une machine à états. En effet les données sont stockées dans des mémoires de grande taille. En considérant une mémoire de 128 Moctets (1G bits), le nombre d’états possible serait de 21G nombre largement supérieur au nombre de particules de l’univers (1080 ).

7.2 Le graphe d’états

7.2.1 Comment représenter graphiquement le comportement d’une machine à états ?

Dans une machine à états donnée, la loi d’évolution de l’état n’est évidemment pas aléatoire, pas plus que celle qui détermine la valeur des sorties. Ces lois sont soigneusement choisies par le créateur de la machine afin que celle-ci remplisse une fonction précise. La conception d’une machine à états, pour peu que sa complexité dépasse celle des cas d’école qui nous serviront d’exemples, est une tâche délicate. Le graphe d’états est l’un des outils les plus utilisés pour la spécification de la machine à états (entrées, sorties, fonctionnement souhaité).

Le graphe d’états, comme son nom l’indique, représente graphiquement les états d’une machine à états. Chaque état est dessiné sous la forme d’une bulle contenant son nom. On comprend immédiatement que cet outil ne sera pas d’un grand secours lorsque le nombre d’états de la machine dépassera quelques dizaines. Prenons l’exemple d’une machine à laver où on considère 5 états comme illustré dans la figure 7.4.

PIC

Fig. 7.4: Graphe d’état au départ

On complète le graphe en figurant les transitions possibles par des flèches entre les états. On appelle état source l’état de départ d’une transition et état destination l’état d’arrivée. La transition T0 a Prélavage pour état source et Lavage pour état destination. Certaines transitions ont le même état pour source et pour destination. Cela signifie que la machine peut rester dans le même état pendant un certain temps. La transition T1 est de cette sorte comme illustré dans la figure 7.5.

PIC

Fig. 7.5: Graphe d’état avec quelques transitions

Muni de toutes les transitions possibles comme représenté dans la figure 7.6, le graphe constitue une représentation assez dense de l’évolution possible de la machine au cours du temps. A tout instant la machine est dans l’un des états représentés ; c’est ce que nous appellerons l’état courant de la machine. A chaque front montant de l’horloge, la machine emprunte l’une des transitions possibles à partir de son état courant. Elle change alors d’état. Retenez bien cette conséquence du fait que notre machine est synchrone sur front montant de l’horloge : elle reste dans un état donné (une bulle du graphe) pendant le temps qui sépare deux fronts montants de l’horloge (voire plus si elle emprunte ensuite une transition vers le même état). Les transitions (les flèches du graphe), en revanche, sont quasi-instantanées puisqu’elles correspondent aux fronts montants de l’horloge.

PIC

Fig. 7.6: Graphe d’état avec les transitions

Pour enrichir encore notre graphe nous devons préciser les spécifications de la machine et, plus particulièrement, la loi d’évolution des variables internes (l’état) en fonction des entrées. Supposons que les entrées de notre machine soient au nombre de trois :

  • M : variable booléenne qui traduit la position du bouton Marche/Arrêt du lave-linge.
  • P : variable booléenne qui indique si le programme de lavage sélectionné par l’utilisateur comporte ou non une phase de prélavage.
  • C : valeur en minutes d’un chronomètre qui est remis à zéro automatiquement au début de chaque étape de lavage.

Les durées des différentes étapes de lavage sont fixées par le constructeur :

  • prélavage : 10 minutes
  • lavage : 30 minutes
  • rinçage : 10 minutes
  • essorage : 5 minutes

A partir de ces informations complémentaires nous pouvons faire figurer sur le graphe les conditions logiques associées à chaque transition. Avec un graphe ainsi complété comme il apparaît dans la figure 7.7, il devient très facile de comprendre ou de prévoir le comportement de la machine. On sait par exemple que lorsque la machine est dans l’état Arrêt elle y reste tant que M n’est pas vrai au moment d’un front montant de l’horloge. Dès que M est vrai au moment d’un front montant de l’horloge la machine change d’état : elle passe dans l’état Prélavage si P est vrai et dans l’état Lavage si P est faux. Il est important de comprendre que la valeur des entrées de la machine n’a d’importance qu’au moment précis des fronts montants de l’horloge. C’est une conséquence du fait que notre machine est synchrone sur front montant de l’horloge.

PIC

Fig. 7.7: Graphe d’état avec les transitions spécifiées

Notre machine à états possède des entrées mais nous n’avons pas encore étudié les sorties. Or un circuit électronique sans sorties n’est que de peu d’utilité. Il existe deux sortes de machines à états : celles dont les sorties ne dépendent que de l’état courant (ce sont les machines dites de Moore) et celles dont les sorties dépendent de l’état courant et des entrées (ce sont les machines dites de Mealy). L’analyse des mérites comparés des machines de Mealy et de Moore est un problème complexe qui n’entre pas dans le cadre de ce cours. Nous allons donc réduire encore la généralité de notre étude et nous concentrer sur les machines de Moore. Le programmateur de notre lave-linge est donc une machine de Moore dont les sorties ne dépendent que de l’état courant. Nous supposerons que ses sorties sont trois signaux booléens, X, Y et Z destinés à piloter les différents moteurs du lave-linge. Les spécifications précisent leur valeur pour chaque état que peut prendre la machine. Nous pouvons encore compléter le graphe d’états afin d’y faire figurer cette information. Le graphe est alors achevé comme illustré dans la figure 7.8. Il est équivalent aux spécifications du programmateur tout en étant plus dense qu’une description en langage naturel.

PIC

Fig. 7.8: Graphe d’état final

7.2.2 Comment vérifier cette représentation à l’aide de quelques règles simples ?

Les spécifications sont généralement écrite en langage naturel. La traduction des spécifications en graphe d’état est donc entièrement manuelle et les risques d’erreurs sont nombreux, comme c’est toujours le cas lorsqu’un humain intervient dans un processus. Si une erreur venait à se glisser dans le graphe elle se retrouverait probablement dans le circuit électronique final (il est peu probable, sauf intervention surnaturelle, qu’une deuxième erreur annule la première), ce qui est inacceptable : un lave-linge qui 'oublie' de rincer n’est pas très satisfaisant, sans parler des centrales nucléaires ou des avions de ligne.

Il faut donc vérifier le graphe avant de poursuivre la réalisation de la machine. Comme toute bonne spécification il doit vérifier deux propriétés fondamentales : :

  • il doit être complet ou non ambigu
  • il doit être non contradictoire

La première signifie que le comportement est toujours défini : à chaque front montant d’horloge, quel que soit l’état dans lequel se trouve la machine et quelles que soient les valeurs des entrées, on doit connaître l’état suivant. L’une des conditions associées aux transitions partant d’un état quelconque du graphe doit donc toujours être vraie. On peut traduire cette propriété sous forme d’équation booléenne en écrivant que le ou logique de toutes les conditions associées au transitions partant d’un état quelconque est toujours vrai : soient C1, C2, ..., Ci, ..., Cn ces conditions, alors :

i=1i=nCi = 1

Par exemple, pour le programmateur de notre lave-linge, les transitions partant de l’état Arrêt sont au nombre de trois comme indiqué en pointillé sur la figure 7.9

PIC

Fig. 7.9: Graphe d’état final

Et les conditions associées sont :

M, M.P , M.P

Le OU logique de ces trois conditions vérifie donc :

M+ M.P + M.P = M + M.(P + P) = M + M = 1

L’état Arrêtrespecte donc la première règle. A titre d’exercice vous pouvez vérifier que c’est également le cas pour les quatre autres états.

La deuxième règle signifie qu’à tout front montant d’horloge une seule transition est possible. Si plus d’une transition a sa condition associée vraie, le graphe est contradictoire (deux actions incompatibles sont simultanément possibles). Le respect de cette règle est plus difficile à vérifier : le OU logique de tous les ET logiques de deux conditions associées aux transitions partant d’un état quelconque est toujours faux :

i=1i=n j=i+1j=nCi.Cj = 0

En reprenant l’état Arrêt du programmateur de lave-linge comme exemple :

M.M.P + M .M.P + M.P.M.P = 0 + 0 + 0 = 0

L’état Arrêt respecte donc également la deuxième règle. Si elle est aussi vérifiée par les autres états alors nous sommes en présence d’un véritable graphe de machine à états sans ambiguïté ni contradiction. Malheureusement cela ne prouve pas que le graphe est conforme à la spécification. Il faut encore vérifier que la fonctionnalité est la même dans les deux descriptions. Il n’existe pas d’outils de vérification ou de formules logiques permettant de le faire. Vous pouvez par exemple parcourir le graphe état par état et, pour chacun d’eux, comparer la partie de spécification qui le concerne avec les conditions associées aux transitions sortantes. Toute méthode est bonne si elle permet d’éviter des erreurs à ce stade du travail de conception.

7.3 La composition d’une machine à états

7.3.1 Le calcul de l’état futur

En logique séquentielle synchrone, l’état courant est modifié à chaque front montant de l’horloge. Entre deux fronts montants de l’horloge (pendant une période d’horloge) il reste stable, ce qui donne le temps aux circuits combinatoires qui composent la machine de calculer le prochain état et les sorties. Il existe donc, entre autres, un circuit combinatoire chargé de calculer le prochain état, que nous appellerons aussi état futur, à partir de l’état courant et des entrées de la machine. Ce circuit (nommé P1 sur le schéma de la figure 7.10) est en général le plus difficile à concevoir. Ses entrées sont :

  • L’état courant qui est mémorisé dans le registre d’état (RE sur le schéma).
  • Les entrées de la machine.

PIC

Fig. 7.10: Calcul de l’état futur

Sa sortie est l’état futur.

Dès que les entrées changent de valeur ou dès que l’état courant est modifié, le circuit P1 commence à calculer l’état futur. Ce calcul n’est pas instantané (voir le TD 5 sur le temps de propagation dans les portes CMOS). Pour que la machine puisse fonctionner correctement il faut que les entrées de ce circuit restent stables pendant une durée suffisante pour que sa sortie puisse, elle aussi, s’établir et se stabiliser avant le front montant de l’horloge suivant. Sinon la valeur échantillonnée par le registre d’état ne sera pas la bonne et le déroulement des opérations sera perturbé.

7.3.2 Le registre d’état

Il est composé de plusieurs bascules D (la question de leur nombre exact est traitée dans le paragraphe 7.4). L’horloge est la même pour toutes : c’est l’horloge générale du circuit électronique dont fait partie la machine. Son entrée est la sortie du circuit P1, c’est l’état futur. Sa sortie, l’état courant, sert d’entrée à P1 mais aussi au circuit destiné à calculer les sorties.

Une machine à état est un dispositif avec rétroaction : l’état courant conditionne les états futurs. Dans un tel dispositif la question des conditions initiales se pose. En d’autres termes, pour que le fonctionnement soit celui souhaité dès la mise sous tension, il faut introduire un moyen de forcer un état de départ. Il en va de même pour le microprocesseur qui constitue l’unité de calcul de votre ordinateur. Comme nous l’avons vu dans le paragraphe 7.1 il contient un grand nombre de machines à états qui le commandent et le contrôlent. Si, lorsque vous allumez votre ordinateur l’état de ces machines n’est pas forcé à une valeur connue et choisie par les concepteurs la séquence de démarrage risque d’être fortement perturbée. C’est pourquoi toute machine à état dispose d’une entrée d’initialisation Reset grâce à laquelle l’état des machines est forcé lors de la mise sous tension.

Il existe deux méthodes pour forcer l’état initial avec le Reset :

  1. Le reset synchrone. Il est pris en compte uniquement sur le front montant de l’horloge. Il agit donc de la même façon que les entrées 'normales' de la machine. Son influence est prioritaire sur les autres. Le circuit P1 possède donc ce signal comme entrée supplémentaire. Lorsque cette entrée est active (elle peut être active lorsqu’elle vaut 0 ou bien 1, c’est une convention à définir) l’état futur que calcule P1 est l’état initial. Au front montant d’horloge suivant la machine passe donc dans cet état. Dans l’exemple de notre programmateur de lave-linge il semble judicieux de choisir Arrêt comme état initial. Le graphe doit être modifié comme indiqué dans la figure 7.11 pour tenir compte du reset synchrone.

    PIC
    Fig. 7.11: Graphe d’état avec Reset synchrone

  2. Le reset asynchrone. Il utilise les entrées Set et Reset des bascules D (voir le chapitre 6) du registre d’état pour forcer l’état initial. On branche l’entrée Reset sur l’entrée set des bascules si on désire forcer un 1, ou sur l’entrée Reset des bascules si on désire forcer un 0. Les entrées de la partie P1 ne sont pas modifiées. Le graphe d’état non plus si ce n’est l’indication de l’état de départ par le Reset comme indiqué dans la figure 7.12. Cette solution est donc plus simple à concevoir que la précédente, donne des tailles (en nombre de composants) plus faibles pour des vitesses de fonctionnement plus élevées. C’est pourquoi on la préférera lorsqu’elle n’entre pas en conflit avec d’autres contraintes.

    PIC
    Fig. 7.12: Graphe d’état avec Reset Asynchrone

7.3.3 Le calcul des sorties

La troisième et dernière partie d’une machine à états est le circuit combinatoire de calcul des sorties (P2 sur le schéma de la figure 7.13). Dans une machine de Moore, ses entrées sont l’état courant et ses sorties sont les sorties de la machine. Dès que l’état courant change, après un front montant d’horloge, ce circuit commence à calculer les sorties caractéristiques du nouvel état. Comme pour le circuit P1 il faut absolument qu’il dispose d’assez de temps pour le faire avant le front montant d’horloge suivant.

PIC

Fig. 7.13: calcul des sorties

7.4 Le codage des états

7.4.1 Comment représenter les différents états sous forme de mots binaires ?

Jusqu’ici nous avons identifié les différents états par leur nom (Arrêt, Prélavage, etc.). L’électronique numérique ne manipule pas de tels symboles. L’alphabet y est nettement plus restreint puisqu’il se compose des seuls 0 et 1 de l’algèbre de Boole. Pour chaque état d’une machine il va donc falloir trouver un nom unique exprimé dans cet alphabet. Nous avons vu dans les paragraphes 7.1 et 7.3 que les machines à états synchrones mémorisent l’état courant dans des bascules D du type de celles du chapitre 6. Chacune de ses bascules contiendra à tout moment un caractère (0 ou 1) du nom de l’état courant.

A la différence des noms d’états exprimés en langage naturel ceux exprimés dans l’alphabet binaire auront tous le même nombre de caractères. La raison en est simple : pour pouvoir mémoriser n’importe quel état dans les bascules D du circuit le nombre de bascules doit être au moins égal à la taille du nom le plus long. Si ces bascules ne servent pas toutes à un instant donné on ne peut en tirer aucun profit ni pour réduire la taille du circuit, ni pour augmenter sa vitesse. L’électronique a ceci de contraignant que le matériel inutilisé coûte aussi cher que le matériel utilisé. Nous allons continuer à exploiter l’exemple du programmateur de lave-linge. Commençons par déterminer le nombre de symboles binaires (bits) nécessaires à représenter les cinq états. Contrairement à ce que l’on pourrait penser ce choix n’est pas trivial. Nous pouvons d’ores et déjà constater que trois bits au moins sont nécessaires. En effet, deux bits permettent, au maximum, la représentation de quatre situations différentes seulement. Deux états différents seraient donc représentés de la même façon et ne pourraient être différenciés ; la machine ne pourrait pas fonctionner correctement. Trois bits permettent de représenter huit mots différents. On peut également éliminer les solutions à plus de cinq bits car elles sont forcément redondantes (il existe toujours au moins un bit inutile que l’on peut retirer en conservant cinq mots différents). Restent les solutions à trois, quatre ou cinq bits.

On appelle codage la représentation en mots binaires des noms des états. La table 7.1 propose un exemple de codage à trois, quatre, cinq et six bits pour notre exemple.

|---------|-----------|----------|---------|
EtatTrois bits |Quatre bits | Cinq bits | Six bits |
|---------|-----------|----------|---------|
Arrêt 100     |   0001    |  11110   | 110001  |
|---------|-----------|----------|---------|
Prélavage-000-----|---0110----|--10100---|-101010--|
Lavage 001     |   1111    |  01100   | 110111  |
|---------|-----------|----------|---------|
Rinçage-010-----|---0000----|--01101---|-010110--|
Essorage 111     |   1011    |  01110   |010111   |

Tab. 7.1: Exemples de codage des états

7.4.2 En quoi le codage choisi influe-t-il sur la taille de la machine à états ?

La partie combinatoire de la machine qui calcule l’état futur en fonction des entrées et de l’état courant est très largement influencée par le codage des états. Donc sa taille (en nombre de composants utilisés) en dépend également. Elle possède Ne + Nb entrées et Nb sorties (Ne est le nombre d’entrées de la machine et Nb le nombre de bits choisi pour coder les états comme illustré dans la figure 7.14).

PIC

Fig. 7.14: Schéma d’une machine à états avec le nombre de bits nécessaires

Le nombre de fonctions booléennes calculées est donc égal à Nb et chacune de ces fonctions possède Ne + Nb entrées. On pourrait en conclure qu’il faut coder les états avec le moins de bits possibles pour que cette partie combinatoire soit la plus petite possible. Mais il n’en est rien. On peut facilement trouver des exemples qui prouvent le contraire. Pour s’en convaincre il suffit de remarquer qu’une fonction booléenne de quatre variables peut être plus simple qu’une autre de deux variables :

F(A0 , A1 , A2 , A3) = A0

est plus simple que :

G(A0 , A1 ) = A0 A1

Il se pourrait que notre exemple soit une illustration de ce phénomène et que cinq fonctions booléennes simples vaillent mieux que trois complexes.

La partie combinatoire qui calcule les sorties en fonctions de l’état courant possède Nb entrées et Ns sorties (où Ns est le nombre de sorties de la machine). Elle calcule donc Ns fonctions booléenne de Nb entrées. Là encore, méfions nous des évidences ; la solution qui se traduit par une taille minimum n’utilise pas nécessairement un codage des états sur un nombre de bits minimum.

La seule certitude que l’on ait concerne le registre d’état. Sa taille est directement liée au nombre de bits du codage d’états. Comme on le voit, le problème n’est pas simple. Il l’est d’autant moins qu’une solution optimale au sens de la taille pour la partie combinatoire de la machine qui calcule l’état futur a peu de chances d’être également la meilleure pour la partie combinatoire qui calcule les sorties.

7.4.3 Quelles méthodes permettent de choisir le meilleur codage possible ?

Il faut, avant de répondre à cette question, déterminer ce que l’on entend par meilleur. La taille est un critère de sélection mais il n’est pas le seul. On peut également s’intéresser à la vitesse de fonctionnement, à la consommation ou la simplicité de conception. Selon l’objectif fixé les stratégies de codage seront différentes. Parmi celles-ci nous allons en citer trois :

  1. Le codage adjacent : il utilise un nombre de bits minimum (trois bits pour l’exemple de la figure 7.15) et se caractérise par le fait que le passage d’un état à un autre ne modifie qu’un seul bit du registre d’état, un peu à la manière d’un code de Gray. Il n’est pas toujours possible de trouver un tel codage. Pour notre programmateur, par exemple, il n’existe pas de codage adjacent. On peut cependant essayer de s’en approcher en réduisant autant que faire se peut, le nombre de transitions modifiant plus d’un bit du registre d’état. Ici, seule la transition de l’état Prélavage, codé 001 à l’état Lavage, codé 010, ne respecte pas la contrainte.

    PIC
    Fig. 7.15: Graphe avec codage adjacent

    L’intérêt d’un tel codage n’est pas systématique. Il donne cependant souvent de bons résultats en taille et en vitesse pour la partie combinatoire qui calcule l’état futur. Elle se trouve en quelque sorte simplifiée par la faible agitation des bits représentant l’état.

  2. Le codage « one-hot »  : il utilise un nombre de bits égal au nombre d’états (cinq bits pour l’exemple de la figure 7.16). Chaque état est représenté par un mot binaire dont tous les bits sauf un valent 0. Ce codage donne souvent les machines les plus simples à concevoir. Il est également parfois intéressant en vitesse et en surface malgré le handicap dû à la taille du registre d’état.

    PIC
    Fig. 7.16: Graphe avec codage 'one-hot'

  3. Le codage aléatoire : il consiste à coder les états sur un nombre de bits minimum sans aucune autre préoccupation que d’éviter que deux états aient le même code. Les résultats en terme de surface, vitesse ou difficulté de conception sont imprévisibles mais peuvent parfois être meilleurs que ceux produits par les deux autres stratégies.

    Pour ce problème précis de l’optimisation du codage des états les outils logiciels de type synthétiseurs logiques peuvent aider le concepteur pour trouver un « bon » codage.

7.5 La conception d’une machine à états

Considérons l’exemple du programmateur du lave-linge (voir le paragraphe 7.2 . Le graphe d’état final représenté dans la figure 7.9 fait apparaître un minuteur qui fournit en entrée de notre machine à états trois signaux C5, C10 et C30, toutes trois booléennes, qui indiquent respectivement si la valeur 5 minutes, 10 minutes ou 30 minutes est atteinte.

Ces minuteurs sont aussi des machines à états dont l’état change à chaque cycle d’horloge, . Ils auraient pu être incorporés au graphe principal, mais en considérant un fréquence d’horloge de 1 seconde, le graphe aurait été muni de plus de 3300 états (5mn + 2fois 10mn + 30mn)* 60 s . Le chapitre 7.5.2 étudie la conception de ces minuteurs.

Les machines à états peuvent donc être factorisables. Cet exemple montre un exemple de machines à états imbriquées de façon à en simplifier leur conception. Commençons par concevoir la machine àà états principale dont le graphe a été étudié préalablement.

7.5.1 machine à états principale

L’interface de la machine avec le monde extérieur est spécifié dans la table 7.2.

|-|----------------------------------------------------------|
NomMode |                       Description                        |
|-|----------------------------------------------------------|
HEntrée |                         Horloge                          |
|-|----------------------------------------------------------|
REntrée-|-----------Reset actif à-0-, initialise-à l’état-Arrêt-------|
MEntrée |             Position du bouton  Marche/Arrêt              |
|-|----------------------------------------------------------|
PEntrée-|------------Existence-d’une-phase-de-prélavage-------------|
C5Entrée |        Chronom  ètre supérieur ou égal à 5 minutes       |
|-|----------------------------------------------------------|
C10Entrée-|--------Chronom-ètre-supérieur-ou-égal à-10-minutes--------|
C30Entrée |        Chronom ètre supérieur ou égal à 30 minutes        |
|-|----------------------------------------------------------|
XSortie-|---------Vaut-0-dans-l’état-Arrêt,-1-dans-les-autres----------|
YSortie | Vaut 1 dans les états Prélavage et Lavage, 0 dans les autres|
|-|----------------------------------------------------------|
ZSortie | Vaut 1 dans les états Lavage et Essorage, 0 dans les autres|

Tab. 7.2: Spécification de l’interface

La première chose à faire est le graphe d’état qui a déjà été étudié au paragraphe 7.2 et vérifié pour ne pas être ambigu ni contradictoire. La figure 7.9 illustre le graphe considéré. Dans une deuxième temps le codage des états doit être choisi. Considérons le codage représenté dans la table 7.3.

|-------|
EtatCodage  |
|-------|
Arrêt000    |
|-------|
Prélavage001----|
Lavage010    |
|-------|
Rinçage110----|
Essorage100    |

Tab. 7.3: Codage des états

Le codage des états choisi est indiqué en haut de chaque bulle du graphe représenté en figure7.17.

PIC

Fig. 7.17: Graphe avec codage choisi pour la conception

Il faut maintenant établir la table de vérité des différentes fonctions booléennes calculées à l’intérieur de la machine.

Commençons par la partie combinatoire qui calcule l’état futur à partir de l’état courant et des entrées, que nous appellerons P1. Nous noterons les trois bits de l’état futur EF2, EF1 et EF0 avec la convention que EF2 est le bit de gauche, EF1 le bit du milieu et EF0 le bit de droite du code de l’état. De même les trois bits de l’état courant seront notés EC2, EC1 et EC0. Cette table de vérité s’appelle également table d’évolution (ou de transition) car elle décrit l’évolution de la machine au cours du temps. Elle donne pour chaque état courant possible et pour chaque combinaison possible des entrées la valeur prise par l’état futur. Lorsque la valeur d’une entrée est X cela signifie qu’elle est indifférente. La table 7.4 représente la table d’évolution de la machine à états.

<IMG alt='|-----|------------------------||-----------------| Etatcourant | Entrées || Etat futur | |-----|----|--|----|-----|-----||-----|-----|-----| EC2EC1EC0 | M |P | C5 | C10 | C30 ||EF2 |EF1 |EF0 | |-----|----|--|----|-----|-----||-----|-----|-----| 00-0---|-0--|X-|-X--|--X--|--X--||-0---|-0---|--0--| 00 0 | 1 |1 | X | X | X || 0 | 0 | 1 | |-----|----|--|----|-----|-----||-----|-----|-----| 00-0---|-1--|0-|-X--|--X--|--X--||-0---|-1---|--0--| 00 1 | X |X | X | 0 | X || 0 | 0 | 1 | |-----|----|--|----|-----|-----||-----|-----|-----| 00-1---|-X--|X-|-X--|--1--|--X--||-0---|-1---|--0--| | | | | | | || | | | 01-0---|-X--|X-|-X--|--X--|--0--||-0---|-1---|--0--| 01-0---|-X--|X-|-X--|--X--|--1--||-1---|-1---|--0--| | | | | | | || | | | 11-0---|-X--|X-|-X--|--0--|--X--||-1---|-1---|--0--| 11 0 | X |X | X | 1 | X || 1 | 0 | 0 | |-----|----|--|----|-----|-----||-----|-----|-----| 10-0---|-X--|X-|-0--|--X--|--X--||-1---|-0---|--0--| 10 0 | X |X | 1 | X | X || 0 | 0 | 0 |