MACHINE DE MOORE SYNCHRONE SIMPLIFIÉE Professeur à l'UHP / ESIAL Alexandre Parodi, Professeur à l'UHP / ESIAL alexandre.parodi@esial.uhp-nancy.fr voir l'animation: Diaporama / Visualiser ... avancer: Barre d'espace ou clic souris reculer: p

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

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

données synchronisation commandes sortie = état INTERFACE

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)

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)

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)

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)

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)

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

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

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

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

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 = 01  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

VALEUR DU NOUVEL ÉTAT À L’EFFACEMENT On veut que : R=1  k  Q  0 (2) Par construction, on a : k  Q  s (0) Pour que (2) soit respecté, par identification, il suffit donc que : RL=1-  s = 0 (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

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 = 00  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

REGISTRE: DÉDUIRE LA SPÉCIFICATION DU RLE R=0  L=1  k Q  D Chargement synchrone R=1  k Q 0 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 01 D Chargement synchrone 1- 0 Effacement synchrone 00 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

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

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

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)

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

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

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

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

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

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

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

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

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

REGISTRE: INTERFACE DU RLE

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

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

REGISTRE: COMPORTEMENT DE LA TRANCHE GÉNÉRIQUE RLE1 01 D Chargement synchrone 1- 0 Effacement synchrone 00 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 01 D Chargement synchrone 1- 0 Effacement synchrone 00 Q Maintien REGISTRE: COMPORTEMENT DE LA TRANCHE GÉNÉRIQUE RLE1

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

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

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 ...  

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

REGISTRE: RÉDUCTION de /s 01 0 0 1 1 00 0 1 1 0 10 0 0 0 0 11 0 0 0 0 ... 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

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 ...  

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

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

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)

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

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

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

FIN DE LA PRESENTATION FIN

FIN DE LA PRESENTATION FIN