MACHINE DE MOORE SYNCHRONE SIMPLIFIÉE Professeur à l'UHP / ESIAL

Présentation au sujet: "MACHINE DE MOORE SYNCHRONE SIMPLIFIÉE Professeur à l'UHP / ESIAL"— Transcription de la présentation:

1 MACHINE DE MOORE SYNCHRONE SIMPLIFIÉE Professeur à l'UHP / ESIAL
Alexandre Parodi, Professeur à l'UHP / ESIAL voir l'animation: Diaporama / Visualiser ... avancer: Barre d'espace ou clic souris reculer: p

2 DÉFINITION La machine de Moore est un opérateur séquentiel synchrone
Séquentiel: sa sortie courante dépend de l’histoire passée des entrées et non pas seulement de l’entrée courante. Elle a donc de la mémoire. Machine à états : l’histoire passée des entrées est représentée par un état interne dont dépend la sortie. Le nouvel état ne dépend donc que de l’état courant mémorisé et de l’entrée courante par une fonction de transition f Synchrone: le changement d’état est synchronisé avec un coup d’horloge (front montant  du signal d’horloge k) k  état  f (état , entrée) Pour simplifier: la sortie est ici égale au code de cet état interne DÉFINITION sortie = état

3 sortie = g(état, entrée)
La machine de Moore est donc un cas particulier d’automate à états finis « Finite State Machine » FSM Finis: le nombre d’états possibles est fini. • Automate de vérification syntaxique (cf. Maths discrètes) seuls les états terminaux peuvent avoir une valeur de sortie TRUE ou FALSE • Machine de Moore usuelle: la sortie est calculée à partir de l’état courant par une fonction g de sortie: sortie = g(état) ici g = fonction identité • Machine de Mealy: la sortie dépend directement de l’état courant et aussi directement de l’entrée courante: sortie = g(état, entrée) AUTRES AUTOMATES

4 données synchronisation commandes sortie = état INTERFACE

5 STRUCTURE f s = f (Q, X) Q  s = f (Q, X) Q  f (Q, X)
Opérateur combinatoire Broches  d’entrée RLE: calcule le nouvel état s en fonction de: • état courant Q ; • entrées X : - données , - commandes . Bascule D (D Flip-Flop): enregistre son entrée D à chaque front montant  de k et l’envoie en sortie Q f fonction de transition f s = f (Q, X) Mémorise l’état courant; enregistre le nouvel état s au coup d ’horloge k au coup d’horloge k l’état Q prend la valeur du nouvel état s Bornes intérieures Pour simplifier, l’état est envoyé directement en sortie Q  s = f (Q, X) STRUCTURE Q  f (Q, X)

6 GÉNÉRATION NOUVEL ÉTAT n°1
b(0) d(0) c(0) e(0) * f nouvel état s = q(1) = f(q(0), X(0)) q(0) q(0) état courant q(0) GÉNÉRATION NOUVEL ÉTAT n°1 q(0)

7 ENREGISTREMENT NOUVEL ÉTAT n°1
b(0) d(0) c(0) e(0) f nouvel état s = q(1) = f(q(0), X(0))   q(1) q(0) ENREGISTREMENT NOUVEL ÉTAT n°1 q(0) q(1)

8 GÉNÉRATION NOUVEL ÉTAT n°2
b(1) d(1) c(1) e(1) * f nouvel état s = q(2) = f(q(1), X(1)) q(1) q(1) état courant q(1) GÉNÉRATION NOUVEL ÉTAT n°2 q(1)

9 ENREGISTREMENT NOUVEL ÉTAT n°2
b(1) d(1) c(1) e(1) f nouvel état s = q(2) = f(q(1), X(1))   q(1) q(2) ENREGISTREMENT NOUVEL ÉTAT n°2 q(1) q(2)

10 EXEMPLE: REGISTRE à EFFACEMENT SPÉCIF DE L’INTERFACE
Donnée à charger Commande d’effacement Commande de chargement Horloge de synchronisation EXEMPLE: REGISTRE à EFFACEMENT SPÉCIF DE L’INTERFACE Sortie de contenu

11 REGISTRE: DÉDUIRE LA STRUCTURE
f REGISTRE: DÉDUIRE LA STRUCTURE

12 REGISTRE: SPÉCIF DU COMPORTEMENT
Tableau de règles « événement  action » ... ... l’événement (conjonction d’une valeur de commande et d’un coup d’horloge) ... ... déclenche l’action (affectation de l’état) REGISTRE: SPÉCIF DU COMPORTEMENT

13 REGISTRE: COMPLÉTER LE COMPORTEMENT
R=0  L=0  k Q  Q Maintien Cas par défaut implicite : pour les autres événements, maintien de l’état courant REGISTRE: COMPLÉTER LE COMPORTEMENT

14 VALEUR DU NOUVEL ÉTAT AU CHARGEMENT
On veut que: R=0  L=1  k  Q  D (1) Par construction, on a : k  Q  s (0) Pour que (1) soit respecté, par identification, il suffit donc que : RL =  s = D (1a) R=0  L=1  et (1a) avec s = D En effet, on a alors k  Q  s (0) donc Q  D VALEUR DU NOUVEL ÉTAT AU CHARGEMENT

15 VALEUR DU NOUVEL ÉTAT À L’EFFACEMENT
On veut que : R=1  k  Q  (2) Par construction, on a : k  Q  s (0) Pour que (2) soit respecté, par identification, il suffit donc que : RL=  s = (2a) L R=1  et (2a) avec s = 0 En effet, on a alors k  Q  s (0) donc Q  0 VALEUR DU NOUVEL ÉTAT À L’EFFACEMENT

16 VALEUR DU NOUVEL ÉTAT EN MAINTIEN
On veut que : R=0  L=0  k  Q  Q (3) Par construction, on a : k  Q  s (0) Pour que (3) soit respecté, par identification, il suffit donc que : RL =  s = Q (3a) R=0  L=0  et (3a) avec s = Q En effet, on a alors k  Q  s (0) donc Q  Q VALEUR DU NOUVEL ÉTAT EN MAINTIEN

17 REGISTRE: DÉDUIRE LA SPÉCIFICATION DU RLE
R=0  L=1  k Q  D Chargement synchrone R=1  k Q  Effacement synchrone R=0  L=0  k Q  Q Maintien Table d’expressions algébriques: pour chaque valeur de commande l’expression algébrique de la sortie en fonction des autres entrées D Chargement synchrone Effacement synchrone Q Maintien On peut ensuite analyser puis synthétiser le RLE fonction f combinatoire Expression algébrique de la sortie s du RLE en fonction de ses entrées D et Q Valeur de commande RL REGISTRE: DÉDUIRE LA SPÉCIFICATION DU RLE

18 REGISTRE: GÉNÉRATION EFFACEMENT (ÉTAT n°1)
- Mot quelconque 1 - f nouvel état s = q(1) = 0 Le nouvel état s est nul  D et L U U état initial q0 = U L’état initial après mise sous tension n’est pas défini : « Unitialized » REGISTRE: GÉNÉRATION EFFACEMENT (ÉTAT n°1) U

19 REGISTRE: ENREGISTREMENT EFFACEMENT (ÉTAT n°1)
- 1 - f nouvel état s = q(1) = 0   U REGISTRE: ENREGISTREMENT EFFACEMENT (ÉTAT n°1) U

20 REGISTRE: GÉNÉRATION CHARGEMENT (ÉTAT n°2)
d 1 f nouvel état s = q(2) = d Le nouvel état s est la donnée D à charger état courant q1 = 0 REGISTRE: GÉNÉRATION CHARGEMENT (ÉTAT n°2)

21 REGISTRE: ENREGISTREMENT CHARGEMENT (ÉTAT n°2)
d 1 f nouvel état s = q(2) = d   d REGISTRE: ENREGISTREMENT CHARGEMENT (ÉTAT n°2) d

22 REGISTRE: GÉNÉRATION MAINTIEN (ÉTAT n°3)
- f nouvel état s = q(3) = Q Le nouvel état s est le même que l’état courant Q d d état courant q2 = d REGISTRE: GÉNÉRATION MAINTIEN (ÉTAT n°3) d

23 REGISTRE: ENREGISTREMENT MAINTIEN (ÉTAT n°3)
- f nouvel état s = q(3) = Q   d d REGISTRE: ENREGISTREMENT MAINTIEN (ÉTAT n°3) d d

24 REGISTRE 4 bits: GÉNÉRATION EFFACEMENT (ÉTAT n°1)
---- 1 - f nouvel état s = q(1) = 0000 Le nouvel état s est nul  D et L UUUU UUUU état courant q0 = UUUU REGISTRE 4 bits: GÉNÉRATION EFFACEMENT (ÉTAT n°1) UUUU

25 REGISTRE 4 bits: ENREGISTREMENT EFFACEMENT (ÉTAT n°1)
---- 1 - f nouvel état s = q (1) = 0000   UUUU 0000 REGISTRE 4 bits: ENREGISTREMENT EFFACEMENT (ÉTAT n°1) UUUU 0000

26 REGISTRE 4 bits: GÉNÉRATION CHARGEMENT (ÉTAT n°2)
1010 1 f nouvel état s = q(2) = 1010 Le nouvel état s est la donnée D=1010 à charger 0000 0000 état courant q1 = 0000 REGISTRE 4 bits: GÉNÉRATION CHARGEMENT (ÉTAT n°2) 0000

27 REGISTRE: ENREGISTREMENT CHARGEMENT (ÉTAT n°2)
1010 1 f nouvel état s = q(2) = 1010   1010 0000 REGISTRE: ENREGISTREMENT CHARGEMENT (ÉTAT n°2) 0000 1010

28 REGISTRE 4 bits: GÉNÉRATION MAINTIEN (ÉTAT n°3)
---- f nouvel état s = q(3) = 1010 Le nouvel état s est le même que l’état courant Q 1010 1010 état courant q(2) = 1010 REGISTRE 4 bits: GÉNÉRATION MAINTIEN (ÉTAT n°3) 1010

29 REGISTRE 4 bits: ENREGISTREMENT MAINTIEN (ÉTAT n°3)
---- f nouvel état s = q(3) = 1010   1010 1010 REGISTRE 4 bits: ENREGISTREMENT MAINTIEN (ÉTAT n°3) 1010 1010

30 REGISTRE: INTERFACE DU RLE

31 L’entrée D2 du RLE est branchée sur l’entrée D de la tranche n°2
Il n’y a pas de retenue ici. Ne pas l’oublier pour une addition ! Commandes communes à toutes les tranches 1 2 3 RLE R L D Q s 1 2 3 Tranches identiques si addition entrée retenue possible Cette tranche n°0 traite le bit n°0 s0 de la sortie s du RLE1 Cette tranche n°2 est l’exemplaire n°2 du modèle de tranche générique commun RLE1 REGISTRE à N=4 bits: DÉCOMPOSITION DU RLE EN 4 TRANCHES IDENTIQUES DE 1 BIT

32 REGISTRE: INTERFACE DE LA TRANCHE MODELE GÉNÉRIQUE RLE1
Cet opérateur traite des données de 1 bit REGISTRE: INTERFACE DE LA TRANCHE MODELE GÉNÉRIQUE RLE1

33 REGISTRE: COMPORTEMENT DE LA TRANCHE GÉNÉRIQUE RLE1
D Chargement synchrone Effacement synchrone Q Maintien Comportement de la tranche modèle générique RLE1 qui sort un seul bit s du mot s Comportement du RLE qui sort un mot s D Chargement synchrone Effacement synchrone Q Maintien REGISTRE: COMPORTEMENT DE LA TRANCHE GÉNÉRIQUE RLE1

34 REGISTRE: RÉDUCTION DU RLE1
Table d ’expressions algébriques de s D Chargement synchrone Effacement synchrone Q Maintien Table de Karnaugh de s Polynôme booléen réduit de s REGISTRE: RÉDUCTION DU RLE1 s = /R . /L . Q + /R . L . D

35 REGISTRE: STRUCTURE DU RLE1 AVEC UN RÉSEAU LOGIQUE DE ETs et OU
/R . /L . Q + /R . L . D /R . /L . Q /R . L . D REGISTRE: STRUCTURE DU RLE1 AVEC UN RÉSEAU LOGIQUE DE ETs et OU

36 REGISTRE: SYNTHÈSE DU RLE1 AVEC DES NANDS
s = /R . /L . Q + /R . L . D // = identité = / / [ (/R . /L . Q) + (/R . L . D) ] Loi de Morgan / [ U + V ] = [ /U . /V ] s = / [ / (/R . /L . Q) . / (/R . L . D) ] NAND / [ A . B ] = A B   s = /(/R . /L . Q) /(/R . L . D)   Parenthèses nécessaires car NAND non associatif ! s = (/R /L Q) (/R L D)   REGISTRE: SYNTHÈSE DU RLE1 AVEC DES NANDS Même polynôme: . et + remplacés par  

37 REGISTRE: STRUCTURE DU RLE1 AVEC UN RÉSEAU LOGIQUE DE NANDS
s = (/R /L Q) (/R L D)   Pour un polynôme, portes ET et OU remplacées par NAND REGISTRE: STRUCTURE DU RLE1 AVEC UN RÉSEAU LOGIQUE DE NANDS

38 REGISTRE: RÉDUCTION de /s
... on entoure donc les 0 on réduit le polynôme booléen de NON s ... Il se trouve qu’ici le polynôme de /s est plus simple que le polynôme de s /s = /L . /Q + L . /D + R REGISTRE: RÉDUCTION de /s

39 REGISTRE: SYNTHÈSE avec NORs
/L . /Q + L . /D + R Polynôme booléen de NON s s = //s = / [ /L . /Q + L . /D + R ] Loi de Morgan: A . B = /(/A + /B) = / [ / ( L + Q ) + / ( /L + D ) + R ] Définition du NOR: /(U + V) = U V   = / [ ( L Q ) + ( /L D ) + R ]   Définition du NOR: /[X + Y + Z] =X Y Z   s = ( L Q ) ( /L D ) R   REGISTRE: SYNTHÈSE avec NORs Même polynôme que /s: . et + remplacés par  

40 REGISTRE: STRUCTURE DU RLE1 AVEC UN RÉSEAU LOGIQUE DE NORs
s = ( L Q ) ( /L D ) R   REGISTRE: STRUCTURE DU RLE1 AVEC UN RÉSEAU LOGIQUE DE NORs

41 REGISTRE: SYNTHÈSE DU RLE1 AVEC UN MUX
s = /R . /L . Q + /R . L . D factorisation = /R . (/L . Q + L . D) Y = C(S, X1, X0) = /S . X0 + S . X1 multiplexeur s = /R • C(L , D , Q) Pas un polynôme booléen ! Fonction C (cf. livre maths num.) REGISTRE: SYNTHÈSE DU RLE1 AVEC UN MUX

42 REGISTRE: STRUCTURE DU RLE1 AVEC UN MUX
s = /R • C(L , D , Q) multiplexeur C(L, D, Q) /R REGISTRE: STRUCTURE DU RLE1 AVEC UN MUX /R . C(L, D, Q)

43 REGISTRE: FONCTIONNEMENT DU RLE1 AVEC UN MUX
Q 1 = 1.Q = Q Q REGISTRE: FONCTIONNEMENT DU RLE1 AVEC UN MUX

44 REGISTRE: FONCTIONNEMENT DU RLE1 AVEC UN MUX
D 1 = 1.D = D D REGISTRE: FONCTIONNEMENT DU RLE1 AVEC UN MUX

45 REGISTRE: FONCTIONNEMENT DU RLE1 AVEC UN MUX
- - 1 - = -.0 = 0 REGISTRE: FONCTIONNEMENT DU RLE1 AVEC UN MUX

46 FIN DE LA PRESENTATION FIN

47 FIN DE LA PRESENTATION FIN