Vous êtes sur la page 1sur 15

Problèmes de machines à états finis synchrones

N.B. Si vous trouvez des erreurs (logiques, pas grammatiques, je sais qu'il-y-a plein de
ces derniers !) dans cette solutionnaire, contactez jeffrey.dungen@polymtl.ca. Merci !

Synthèse : Détecteur de séquence

Concevez une machine capable de détecter la séquence 0-1-1-0 sur son unique entrée (x).
Quand la séquence se produit, il devrait émettre un 1 sur son unique sortie (y). Une
diagramme temporelle du comportement attendu est donné. Notez que dans la séquence
0-1-1-0-1-1-0, la séquence se produit deux fois ! Utilisez une machine de Moore.

x y x
y
CLK
CLK

N'oubliez pas de commencer par une diagramme d'états, d'essayer de minimiser le


nombre d'états et de choisir les bascules qui minimisent le coût (D, T ou JK).

Diagramme d'états :

Rien 1
0

0 «0»
1

0 «01»
1
1
«011»
0
0 1
«0110»
Table d'états suivants :

État suivant quand x =


État courant Sortie
0 1
Rien «0» Rien 0
«0» «0» «01» 0
«01» «0» «011» 0
«011» «0110» Rien 0
«0110» «0» «01» 1

Est-ce-qu'on peut fusionner des états ? Non, parce-que parmi les états qui ont la même
sortie, aucuns n'ont les mêmes états suivants.

Table d'états :

État courant État suivant (Y) quand x =


Sortie
y2y1y0 0 1
000 (Rien) 001 000 0
001 («0») 001 011 0
011 («01») 001 010 0
010 («011») 110 000 0
110 («0110») 001 011 1

Il-y-a cinq états, alors on a besoin de trois bascules. Trois bascules nous donnent trois
bits d'état – c'est à dire 23 = 8 états possibles. Avec deux bascules on n'aura que 22 = 4
états possibles, ce qui sera insuffisant.

C'est possible d'assigner des codes aux états d'une autre façon. Ici on a choisi 000 comme
l'état de défaut par convention. On a essayé de faire que les codes des états suivants sont
adjacents. Et finalement, on a fait que «0110» a une code distincte (c'est la seule où y2 =
1) pour faciliter la logique de sortie.

Simplification des états suivants :

On remarque que Y2 n'est 1 que dans une seule condition (avec aucun cas facultatif
adjacent). Alors on peut le simplifier directement : Y2 = !y2y1!y0!x (pour bascule D)

Pour les autres, on utilise des tables de Karnaugh :


Y1 (D) Y1 (T)
y2y1\y0x 00 01 11 10 y2y1\y0x 00 01 11 10
00 0 0 1 0 00 0 0 1 0
01 1 0 1 0 01 0 1 0 1
11 0 1 - - 11 1 0 - -
10 - - - - 10 - - - -

Y1 (J) Y1 (K)
y2y1\y0x 00 01 11 10 y2y1\y0x 00 01 11 10
00 0 0 1 0 00 - - - -
01 - - - - 01 0 1 0 1
11 - - - - 11 1 0 - -
10 - - - - 10 - - - -

C'est moins cher d'utiliser une bascule JK et d'encercler les 1 dans les deux cas. Si vous
n'êtes pas convaincu de ce fait, il faudrait simplifier chaque table de Karnaugh de forme
disjonctive et conjonctive et comparer les coûts !

Alors, Y1J = y0x et Y1K = y2 y0 x (un ou-exclusif de ces trois)

Y0 (D) Y0 (T)
y2y1\y0x 00 01 11 10 y2y1\y0x 00 01 11 10
00 1 0 1 1 00 1 0 0 0
01 0 0 0 1 01 0 0 1 0
11 1 1 - - 11 1 1 - -
10 - - - - 10 - - - -

Y0 (J) Y0 (K)
y2y1\y0x 00 01 11 10 y2y1\y0x 00 01 11 10
00 1 0 - - 00 - - 0 0
01 0 0 - - 01 - - 1 0
11 1 1 - - 11 - - - -
10 - - - - 10 - - - -

Encore, c'est moins cher d'utiliser une bascule JK et d'encercler les 1 dans les deux cas.
Si vous n'êtes pas convaincu de ce fait, il faudrait simplifier chaque table de Karnaugh de
forme disjonctive et conjonctive et comparer les coûts !
Alors, Y1J = y2 + !y1!x et Y1K = y1x

Simplification de la sortie :

Selon notre choix de variables d'état, la sortie est simple. La sortie est 1 quand y2 = 1.

Circuit final :

À venir quand c'est confirmé que Jeff n'a fait aucune erreur jusqu'à ce point. :-)
Synthèse : Machine de Poly-Cola

Concevez une machine qui vend du Poly-Cola. Une bouteille de Poly-Cola coute 1$. La
machine accepte des 25¢ et des 1$. Dès que la machine obtient exactement 1$, ça lâche
une bouteille. Si plus que 1$ est inséré dans la machine (par un usager con), la machine
devrait simplement lâcher cet argent et retourner à son état initial.

Il-y-a deux entrées : 25¢ et 1$. Ces entrées pulsent à 1 pendant une seule cycle d'horloge
pour indiquer quand le sous correspondant est reçu.

Il-y-a deux sorties : lâche une bouteille et lâche l'argent. Il suffit d'envoyer une pulse de
1 pendant une seule cycle d'horloget pour assurer qu'une bouteille ou l'argent est lâché.

25¢ Bouteille
1$ POLY
CLK Argent

Concevez la machine en premier comme machine de Moore, et de suite comme machine


de Mealy. Laquelle est plus simple et moins coûteuse ?

N'oubliez pas de commencer par une diagramme d'états, d'essayer de minimiser le


nombre d'états et de choisir les bascules qui minimisent le coût (D, T ou JK).

Diagrammes d'états :
MOORE MEALY
0¢ 00/00 0¢
00
10 01/10 10/00
01
25¢ XX 25¢ 01/01
00 01 00/00
10 Retour 10/00
XX
01
50¢ d'argent 50¢ 01/01
00 00/00
10 01 10/00

75¢ 10 1$ 75¢ 01/01


00 00/00 10/10

Avec Moore, il-y-a six états (trois bascules), tandis-qu'avec Mealy il-y-a quatre états
(deux bascules). C'est à dire qu'avec Mealy on sauve une bascule.

Notez que dans la machine de Moore, on aurait pu ajouter des conditions où la machine
peut aller dans l'état 25¢/1$ après avoir été dans l'état 1$ ou Retour d'argent. Mais,
puisque c'est quasiment impossible que quelqu'un ajoute deux sous en deux cycles
d'horloge suivantes, on ignore cette possibilité. La machine devrait simplifier mieux par
conséquent.

Notez aussi que c'est impossible d'avoir 1$ et 25¢ ajoutés pendant la même cycle
d'horloge. Alors on peut ignorer le cas où QL (Quarter/Loonie) = 11.

Table d'états suivants (Moore) :

État suivant quand QL =


État courant Sorties (BA)
00 01 10 11
0¢ 0¢ $1.00 25¢ - 00
25¢ 25¢ Ret 50¢ - 00
50¢ 50¢ Ret 75¢ - 00
75¢ 75¢ Ret $1.00 - 00
$1.00 0¢ 0¢ 0¢ - 10
Retour 0¢ 0¢ 0¢ - 01

Il-n'y-a aucune paire d'états fusionnables.

Table d'états (Moore) :

État courant État suivant quand QL =


Sorties (BA)
y2y1y0 00 01 10 11
000 (0¢) 000 110 001 - 00
001 (25¢) 001 100 011 - 00
011 (50¢) 011 100 010 - 00
010 (75¢) 010 100 110 - 00
110 ($1.00) 000 000 000 - 10
100 (Retour) 000 000 000 - 01

C'est possible d'assigner des codes aux états d'une autre façon. Ici le chemin de 0¢ à $1
consiste de de transitions adjacents dans le but de simplifier la logique. Les états $1 et
Retour, qui sont les seuls à avoir une sortie, sont distincts puisqu'ils ont y2 = 1. Ceci
devrait simplifier les sorties.
Simplification des états suivants (Moore) :

Y2 (D) quand y2 = 0 Y2 (D) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 1 - 0 00 0 0 - 0
01 0 1 - 0 01 - - - -
11 0 1 - 0 11 - - - -
10 0 1 - 1 10 0 0 - 0

Y2 (T) quand y2 = 0 Y2 (T) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 1 - 0 00 1 1 - 1
01 0 1 - 0 01 - - - -
11 0 1 - 0 11 - - - -
10 0 1 - 1 10 1 1 - 1

Y2 (J) quand y2 = 0 Y2 (J) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 1 - 0 00 - - - -
01 0 1 - 0 01 - - - -
11 0 1 - 0 11 - - - -
10 0 1 - 1 10 - - - -

Y2 (K) quand y2 = 0 Y2 (K) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 - - - - 00 1 1 - 1
01 - - - - 01 - - - -
11 - - - - 11 - - - -
10 - - - - 10 1 1 - 1

Pour Y2, c'est le moins coûteux avec une bascule JK.

Y2J = L + y1!y0Q et Y2K = 1 (oui, on 'Kill' toujours !)


Y1 (D) quand y2 = 0 Y1 (D) quand y2 = 1
y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 1 - 0 00 0 0 - 0
01 0 0 - 1 01 - - - -
11 1 0 - 1 11 - - - -
10 1 0 - 1 10 0 0 - 0

Y1 (T) quand y2 = 0 Y1 (T) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 1 - 0 00 0 0 - 0
01 0 0 - 1 01 - - - -
11 0 1 - 0 11 - - - -
10 0 1 - 0 10 1 1 - 1

Y1 (J) quand y2 = 0 Y1 (J) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 1 - 0 00 0 0 - 0
01 0 0 - 1 01 - - - -
11 - - - - 11 - - - -
10 - - - - 10 - - - -

Y1 (K) quand y2 = 0 Y1 (K) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 - - - - 00 - - - -
01 - - - - 01 - - - -
11 0 1 - 0 11 - - - -
10 0 1 - 0 10 1 1 - 1

Pour Y1, c'est le moins coûteux avec une bascule JK.

Y1J = y0Q + !y2!y0L et Y1K = y2 + L


Y0 (D) quand y2 = 0 Y0 (D) quand y2 = 1
y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 0 - 1 00 0 0 - 0
01 1 0 - 1 01 - - - -
11 1 0 - 0 11 - - - -
10 0 0 - 0 10 0 0 - 0

Y0 (T) quand y2 = 0 Y0 (T) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 0 - 1 00 0 0 - 0
01 1 0 - 1 01 - - - -
11 0 1 - 1 11 - - - -
10 1 1 - 1 10 1 1 - 1

Y0 (J) quand y2 = 0 Y0 (J) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 0 - 1 00 0 0 - 0
01 1 0 - 1 01 - - - -
11 - - - - 11 - - - -
10 - - - - 10 - - - -

Y0 (K) quand y2 = 0 Y0 (K) quand y2 = 1


y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 - - - - 00 - - - -
01 - - - - 01 - - - -
11 0 1 - 1 11 - - - -
10 1 1 - 1 10 1 1 - 1

Pour Y0, c'est le moins coûteux avec une bascule D.

Y0 = y0!Q!L + !y2y1Q
Simplification des sorties (Moore) :

Heureusement on peut simplifier les sorties directement de la table d'états puisque pour
chacune, il-y-a juste un cas ou c'est 1. Alors, B = y2y1 et A = y2!y1

Circuit final :

À venir quand c'est confirmé que Jeff n'a fait aucune erreur jusqu'à ce point. :-)
Maintenant, il faut l'implémenter comme machine de Mealy pour qu'on puisse comparer
les deux solutions selon leur cout...

Table d'états suivants (Mealy) :

État État suivant quand QL = Sorties (BA) quand QL =


courant 00 01 10 11 00 01 10 11
0¢ 0¢ 0¢ 25¢ - 00 10 00 -
25¢ 25¢ 0¢ 50¢ - 00 01 00 -
50¢ 50¢ 0¢ 75¢ - 00 01 00 -
75¢ 75¢ 0¢ 0¢ - 00 01 10 -

Il-n'y-a aucune paire d'états fusionnables.

Table d'états (Mealy) :

État courant État suivant quand QL = Sorties (BA) quand QL =


y1y0 00 01 10 11 00 01 10 11
00 (0¢) 00 00 01 - 00 10 00 -
01 (25¢) 01 00 11 - 00 01 00 -
11 (50¢) 11 00 10 - 00 01 00 -
10 (75¢) 10 00 00 - 00 01 10 -

C'est possible d'assigner des codes aux états d'une autre façon. Ici le chemin de 0¢ à 75¢
et de retour à 0¢ consiste de de transitions adjacents dans le but de simplifier la logique.
Simplification des états suivants (Mealy) :

Y1 (D) Y1 (T)
y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 0 - 0 00 0 0 - 0
01 0 0 - 1 01 0 0 - 1
11 1 0 - 1 11 0 1 - 0
10 1 0 - 0 10 0 1 - 1

Y1 (J) Y1 (K)
y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 0 - 0 00 - - - -
01 0 0 - 1 01 - - - -
11 - - - - 11 0 1 - 0
10 - - - - 10 0 1 - 1

C'est le moins cher avec une bascule JK (JK = 12, D = 13).


Y1J = y0Q et Y1K = L + !y0Q

Y0 (D) Y0 (T)
y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 0 - 1 00 0 0 - 1
01 1 0 - 1 01 0 1 - 0
11 1 0 - 0 11 0 1 - 1
10 0 0 - 0 10 0 0 - 0

Y0 (J) Y0 (K)
y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 0 - 1 00 - - - -
01 - - - - 01 0 1 - 0
11 - - - - 11 0 1 - 1
10 0 0 - 0 10 - - - -

Encore, c'est le moins cher avec une bascule JK (JK = 12, D = 13).
Y0J = !y1Q et Y0K = L + y1Q
Simplification des sorties (Mealy) :

B A
y1y0\QL 00 01 11 10 y1y0\QL 00 01 11 10
00 0 1 - 0 00 0 0 - 0
01 0 0 - 0 01 0 1 - 0
11 0 0 - 0 11 0 1 - 0
10 0 0 - 1 10 0 1 - 0

B = !y1!y0L + y1!y0Q et A = !L · (y1 + y0)

Circuit final :

À venir quand c'est confirmé que Jeff n'a fait aucune erreur jusqu'à ce point. :-)

Comparaison :

La machine de Moore a un coût logique (Y2 + Y1 + Y0 + A + B) de (9 + 17 + 14 + 4 + 4)


= 48
La machine de Mealy a un coût logique (Y1 + Y0 + A + B) de (12 + 12 + 8 + 14) = 46

Étant donné que la machine de Mealy requiert une bascule de moins que celle de Moore,
et son coût est inférieur, on peut conclure que la machine de Mealy est moins chère.
Analyse : Détecteur de séquence

Le circuit suivant est un détecteur de séquence. En suivant les étapes de l'analyse,


déterminez quelle séquence ce circuit détecte.

x
Y1 y1

CLK
Y0 y0 y

CLK

Dès que vous obtenez la diagramme d'états, c'est facile de déterminer cette séquence.
Astuce : l'état initial est y1y0 = 00. Dans cet état, aucune partie de la séquence n'a été
détectée.

Table d'états :

Si ce n'est pas évident comment passer directement du circuit à cette table, trouvez en
premier les équations pour Y1 et Y0 puis déterminez leur sorties selon toutes les
combinaisons d'entrées possibles (comme dans la colonne à gauche dans la table.

État courant État suivant (Y1Y0) quand x =


Sortie
y1y0 0 1
00 00 01 0
01 11 01 0
10 11 01 1
11 00 10 0
Table d'états suivants :

Maintenant, on sait que l'état 00 est l'état initial, alors on le nomme «Rien». On peut
facilement nommer les autres états. Comment ? On leur accorde comme nom la
séquence qu'on a eu à date sur l'entrée :

État suivant quand x =


État courant Sortie
0 1
Rien (00) 00 01 0
«1» (01) 11 01 0
«101» (10) 11 01 1
«10» (11) 00 10 0

On n'a même pas besoin de dessiner une diagramme d'états. On voit que dès qu'on
obtient la séquence 1-0-1, la sortie devient 1. Quand même, voici la diagramme d'états
pour mieux comprendre comment fonctionne ce circuit :

0 Rien
1

«1» 1
0

0 «10»
1

«101» 1
0

Ce circuit est donc un détecteur de la séquence 1-0-1.

Centres d'intérêt liés