Problèmes de machines à états finis synchrones

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 [email protected]. 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
x
y
CLK
y
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
«011»
0
0
1
«0110»
1
Table d'états suivants :
État courant
État suivant quand x =
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 :
10
0
y2y1\y0x
00
Y1 (D)
00
01
11
0
0
1
00
00
0
01
1
0
1
0
01
0
1
0
1
11
0
1
-
-
11
1
0
-
-
10
-
-
-
-
10
-
-
-
-
00
00
0
Y1 (J)
01
0
11
1
10
0
01
-
-
-
-
11
-
-
-
-
11
1
0
-
-
10
-
-
-
-
10
-
-
-
-
y2y1\y0x
y2y1\y0x
Y1 (T)
01
11
0
1
Y1 (K)
y2y1\y0x 00
01
11
00
0
1
0
01
10
0
10
1
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)
y2y1\y0x
Y0 (D)
01
11
0
1
10
1
y2y1\y0x
00
00
1
Y0 (T)
01
11
0
0
00
00
1
01
0
0
0
1
01
0
0
1
0
11
1
1
-
-
11
1
1
-
-
10
-
-
-
-
10
-
-
-
-
11
-
10
-
y2y1\y0x
00
00
1
Y0 (J)
01
0
01
0
0
-
-
01
-
-
1
0
11
1
1
-
-
11
-
-
-
-
10
-
-
-
-
10
-
-
-
-
y2y1\y0x
00
Y0 (K)
00
01
11
0
10
0
10
0
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¢
1$
CLK
Bouteille
POLY
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
0¢
00
00
00
00
MEALY
10
25¢
10
50¢
10
0¢
00/00
01/10 10/00
01
01
01
XX
Retour
d'argent
01
75¢ 10
1$
00/00
XX
00/00
00/00
25¢ 01/01
10/00
50¢ 01/01
10/00
75¢ 01/01
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 courant
État suivant quand QL =
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) :
y1y0\QL
00
Y2 (D) quand y2 = 0
00
01
11
0
1
-
10
0
y1y0\QL
00
Y2 (D) quand y2 = 1
00
01
11
0
0
-
10
0
01
0
1
-
0
01
-
-
-
-
11
0
1
-
0
11
-
-
-
-
10
0
1
-
1
10
0
0
-
0
10
0
y1y0\QL
y1y0\QL
00
Y2 (T) quand y2 = 0
00
01
11
0
1
-
00
Y2 (T) quand y2 = 1
00
01
11
1
1
-
10
1
01
0
1
-
0
01
-
-
-
-
11
0
1
-
0
11
-
-
-
-
10
0
1
-
1
10
1
1
-
1
10
0
y1y0\QL
y1y0\QL
00
Y2 (J) quand y2 = 0
00
01
11
0
1
-
00
Y2 (J) quand y2 = 1
00
01
11
-
10
-
01
0
1
-
0
01
-
-
-
-
11
0
1
-
0
11
-
-
-
-
10
0
1
-
1
10
-
-
-
-
10
-
y1y0\QL
y1y0\QL
00
Y2 (K) quand y2 = 0
00
01
11
-
00
Y2 (K) quand y2 = 1
00
01
11
1
1
-
10
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 !)
y1y0\QL
00
Y1 (D) quand y2 = 0
00
01
11
0
1
-
10
0
y1y0\QL
00
Y1 (D) quand y2 = 1
00
01
11
0
0
-
10
0
01
0
0
-
1
01
-
-
-
-
11
1
0
-
1
11
-
-
-
-
10
1
0
-
1
10
0
0
-
0
10
0
y1y0\QL
y1y0\QL
00
Y1 (T) quand y2 = 0
00
01
11
0
1
-
00
Y1 (T) quand y2 = 1
00
01
11
0
0
-
10
0
01
0
0
-
1
01
-
-
-
-
11
0
1
-
0
11
-
-
-
-
10
0
1
-
0
10
1
1
-
1
10
0
y1y0\QL
y1y0\QL
00
Y1 (J) quand y2 = 0
00
01
11
0
1
-
00
Y1 (J) quand y2 = 1
00
01
11
0
0
-
10
0
01
0
0
-
1
01
-
-
-
-
11
-
-
-
-
11
-
-
-
-
10
-
-
-
-
10
-
-
-
-
10
-
y1y0\QL
y1y0\QL
00
Y1 (K) quand y2 = 0
00
01
11
-
00
Y1 (K) quand y2 = 1
00
01
11
-
10
-
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
y1y0\QL
00
Y0 (D) quand y2 = 0
00
01
11
0
0
-
10
1
y1y0\QL
00
Y0 (D) quand y2 = 1
00
01
11
0
0
-
10
0
01
1
0
-
1
01
-
-
-
-
11
1
0
-
0
11
-
-
-
-
10
0
0
-
0
10
0
0
-
0
10
1
y1y0\QL
y1y0\QL
00
Y0 (T) quand y2 = 0
00
01
11
0
0
-
00
Y0 (T) quand y2 = 1
00
01
11
0
0
-
10
0
01
1
0
-
1
01
-
-
-
-
11
0
1
-
1
11
-
-
-
-
10
1
1
-
1
10
1
1
-
1
10
1
y1y0\QL
y1y0\QL
00
Y0 (J) quand y2 = 0
00
01
11
0
0
-
00
Y0 (J) quand y2 = 1
00
01
11
0
0
-
10
0
01
1
0
-
1
01
-
-
-
-
11
-
-
-
-
11
-
-
-
-
10
-
-
-
-
10
-
-
-
-
10
-
y1y0\QL
y1y0\QL
00
Y0 (K) quand y2 = 0
00
01
11
-
00
Y0 (K) quand y2 = 1
00
01
11
-
10
-
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 suivant quand QL =
Sorties (BA) quand QL =
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
-
État
courant
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) :
y1y0\QL
Y1 (D)
01
11
0
-
10
0
y1y0\QL
00
00
0
Y1 (T)
01
11
0
-
00
00
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
y1y0\QL
Y1 (J)
01
0
11
-
10
0
y1y0\QL
00
00
0
00
00
-
01
0
0
-
1
01
-
-
-
-
11
-
-
-
-
11
0
1
-
0
10
-
-
-
-
10
0
1
-
1
Y1 (K)
01
11
-
10
0
10
-
C'est le moins cher avec une bascule JK (JK = 12, D = 13).
Y1J = y0Q et Y1K = L + !y0Q
y1y0\QL
Y0 (D)
01
11
0
-
10
1
y1y0\QL
00
00
0
Y0 (T)
01
11
0
-
00
00
0
01
1
0
-
1
01
0
1
-
0
11
1
0
-
0
11
0
1
-
1
10
0
0
-
0
10
0
0
-
0
11
-
10
1
y1y0\QL
00
00
0
Y0 (J)
01
0
01
-
-
-
11
-
-
10
0
0
y1y0\QL
10
1
00
Y0 (K)
00
01
11
-
10
-
-
01
0
1
-
0
-
-
11
0
1
-
1
-
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
01
1
11
-
10
0
y1y0\QL
00
00
0
01
0
0
-
11
0
0
10
0
0
y1y0\QL
00
00
0
A
01
0
11
-
10
0
0
01
0
1
-
0
-
0
11
0
1
-
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 courant
État suivant quand x =
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 :
Rien
0
1
«1»
0
0
«10»
1
«101» 1
0
Ce circuit est donc un détecteur de la séquence 1-0-1.
1