← Retour au blogLogique séquentielle

Maîtriser la logique séquentielle : le latch D expliqué et simulé

Un latch D transforme un cœur SR commandé en mémoire à une seule entrée. Déduisez son équation, comprenez la transparence et découvrez les limites temporelles cachées par le symbole.

DennyDenny
9 min de lecture
Chalkboard feature illustration for “Maîtriser la logique séquentielle : le latch D expliqué et simulé”

En bref : un latch D mémorise un bit et obéit à Qnext=(ED)+(E‾Q)Q_{next}=(E D)+(\overline{E}Q). Quand Enable est HIGH, Q suit D après le délai de propagation ; quand Enable est LOW, Q conserve sa valeur. La commande par D et D‾\overline D empêche l’entrée de données ordinaire d’activer simultanément set et reset, mais un latch physique reste soumis aux contraintes de setup et de hold et peut devenir métastable près de son front de fermeture.

L’étude de la logique séquentielle commence souvent par le latch SR. Ses deux commandes indépendantes autorisent une combinaison active invalide. Un latch D commandé déduit ces commandes d’une seule entrée de données et de son complément, élimine cette combinaison en fonctionnement normal et définit explicitement la période pendant laquelle de nouvelles données peuvent entrer.

Schéma du composant D_LATCH

Décomposer le D_LATCH : sa nature et son importance

Un D_LATCH est avant tout un élément de mémoire sensible au niveau, dérivé d’une structure SR. Dans le modèle booléen, sa logique d’entrée garantit que Set et Reset s’excluent mutuellement. Il se place entre logique combinatoire et stockage déclenché sur un front : les portes dépendent des entrées présentes, tandis que le latch peut conserver une valeur antérieure.

Le composant possède deux entrées principales et deux sorties :

  • D — Data : une entrée unique qui détermine la valeur, 0 ou 1, à mémoriser.
  • E — Enable : souvent notée « E » ou « G » pour Gate, cette entrée joue le rôle d’un interrupteur de commande. Elle indique quand le latch doit tenir compte de D.
  • Q : sortie principale qui reflète les données mémorisées.
  • Q‾\overline{Q} : sortie complémentée — inversée — des données mémorisées.

Le comportement comporte deux modes distincts selon l’état du signal Enable. Pour E=1E = 1, le latch est en mode transparent : la sortie Q suit simplement D. Si D change, Q change à son tour presque immédiatement. Pour E=0E = 0, le latch passe en mode mémorisé : Q ignore totalement D et conserve la dernière valeur présente juste avant le passage de E de 1 à 0.

Explorer le comportement de D_LATCH

Spécification technique et table de vérité

Pour maîtriser le D_LATCH, il faut dépasser son symbole et comprendre la logique qui gouverne ses transitions d’état. La table de vérité définit clairement l’état suivant de Q (QnextQ_{next}) à partir des entrées présentes. Lorsque E vaut 0, D n’a aucune importance ; on le note « X », pour « indifférent ».

E (Enable)D (Data)QnextQ_{next}Action
0XQQConserver — mémorisé
100Reset — transparent
111Set — transparent

Équation caractéristique

Le comportement se formule mathématiquement avec l’équation caractéristique du D_LATCH. Elle définit formellement le fonctionnement du circuit et devient indispensable pour simplifier de grands systèmes séquentiels par l’algèbre booléenne.

Qnext=(E⋅D)+(E‾⋅Q)Q_{next} = (E \cdot D) + (\overline{E} \cdot Q)

Déduisons-la à partir des principes de base. Le D_LATCH contient un latch SR commandé où :

  • S=E⋅DS = E \cdot D
  • R=E⋅D‾R = E \cdot \overline{D}

L’équation caractéristique du latch SR est Qnext=S+R‾⋅QQ_{next} = S + \overline{R} \cdot Q. En remplaçant les termes :

Qnext=(E⋅D)+(E⋅D‾)‾⋅QQ_{next} = (E \cdot D) + \overline{(E \cdot \overline{D})} \cdot Q

La loi de De Morgan donne (E⋅D‾)‾=E‾+D\overline{(E \cdot \overline{D})} = \overline{E} + D. Ainsi :

Qnext=(E⋅D)+(E‾+D)⋅Q=(E⋅D)+(E‾⋅Q)+(D⋅Q)Q_{next} = (E \cdot D) + (\overline{E} + D) \cdot Q = (E \cdot D) + (\overline{E} \cdot Q) + (D \cdot Q)

Comme (E⋅D)(E \cdot D) couvre déjà le cas où D et Q sont tous deux pertinents, le terme (D⋅Q)(D \cdot Q) est absorbé par simplification booléenne — théorème du consensus — et il reste :

Qnext=(E⋅D)+(E‾⋅Q)Q_{next} = (E \cdot D) + (\overline{E} \cdot Q)

Décomposons ses éléments logiques :

  • Le terme E⋅DE \cdot D représente la transparence : si Enable est haut, la sortie prend la valeur de D.
  • Le terme E‾⋅Q\overline{E} \cdot Q représente la mémoire : si Enable est bas, la sortie conserve son état Q actuel.
  • L’équation cache un multiplexeur : Enable choisit entre les nouvelles données et la valeur mémorisée.

La logique interne : de SR à D

Le D_LATCH peut être vu comme un « SR_LATCH commandé » auquel on ajoute une astuce. Dans sa structure de portes interne, l’entrée D alimente directement le côté Set, tandis qu’une version inversée de D — obtenue par une porte NOT — alimente Reset. Cela garantit que S et R restent opposés lorsque le circuit est activé.

  • S=E⋅DS = E \cdot D
  • R=E⋅D‾R = E \cdot \overline{D}

Pour E=1E=1, D=1D=1 produit Set et D=0D=0 produit Reset. Le chemin de données ordinaire ne peut donc pas commander les deux simultanément. Pour E=0E=0, les deux commandes sont désactivées et le cœur conserve son état. Dans la réalité, les portes ne commutent pas simultanément : les transitions de D et Enable proches de la fermeture peuvent violer les contraintes temporelles. Le latch D évite donc l’erreur de la table de vérité SR sans supprimer la métastabilité.

Schéma du composant SR_LATCH

Piège fréquent : les risques de la transparence

La plus grande force du D_LATCH — sa transparence — est aussi sa faiblesse principale dans les systèmes complexes à haute vitesse. C’est le piège critique auquel se heurtent de nombreux étudiants lorsqu’ils passent de circuits simples à la conception d’un processeur.

Puisque Q suit D pendant toute la durée où Enable est haut, chaque bruit, glitch ou changement involontaire de la ligne D traverse directement jusqu’à la sortie. On parle d’un comportement sensible au niveau.

Imaginez que le signal Enable soit une fenêtre. Quand E=1E=1, elle est grande ouverte : vous voyez en temps réel tout ce qui se passe dehors — l’entrée D —, qu’il s’agisse d’un oiseau ou d’une feuille qui tombe — les « glitches ». Quand E=0E=0, la vitre se dépolit instantanément et conserve l’image exacte de la dernière chose observée.

Pourquoi la transparence est dangereuse en pratique : considérons un système où la sortie d’un D_LATCH traverse une logique combinatoire puis revient vers l’entrée de ce même latch ou d’un autre. Tant qu’Enable est haut, toute modification de la sortie se propage immédiatement dans la logique et réapparaît à l’entrée, ce qui modifie de nouveau la sortie. Ce chemin de rétroaction combinatoire peut provoquer :

  1. Plusieurs changements d’état involontaires pendant une seule fenêtre d’activation.
  2. La propagation des glitches, lorsqu’une impulsion transitoire sur la ligne de données atteint Q et corrompt les circuits en aval.
  3. Un timing imprévisible, où la valeur finalement mémorisée dépend de l’instant précis auquel Enable retombe — un cauchemar pour la vérification.

Beaucoup de systèmes synchrones utilisent des bascules D, dont la capture visible de l’extérieur est associée à un front d’horloge. D’autres systèmes performants emploient volontairement des latchs à deux phases pour emprunter du temps. Aucun de ces choix ne supprime l’analyse temporelle ; chacun définit un ensemble différent de contraintes de setup, de hold, de transparence et d’horloge.

Vérification à l’oscilloscope : observer le signal

Pour comprendre réellement le timing d’un D_LATCH, il faut voir ses formes d’onde. Dans digisim.io, OSCILLOSCOPE est votre meilleur allié pour déboguer ces relations temporelles.

En reliant un OSCILLOSCOPE aux broches E, D et Q, vous observerez plusieurs comportements essentiels :

  1. Délai de propagation (tpdt_{pd}) : un composant physique ou un modèle tenant compte des délais montre le temps qui sépare un changement de D de la réponse de Q pendant la transparence. Un simulateur logique idéal peut ne pas représenter ce délai.
  2. Instant de mémorisation : observez Q exactement lorsque E retombe de 1 à 0. La valeur de D à cette microseconde précise est celle que Q conservera, quoi que fasse D ensuite.
  3. Capture des glitches : si vous basculez rapidement D pendant que E est haut, les impulsions se reflètent sur Q. Si vous basculez D quand E est bas, la trace Q de l’OSCILLOSCOPE reste une ligne horizontale parfaitement stable.

Ouvrir la démonstration à l’oscilloscope

Applications concrètes : au-delà de la platine d’expérimentation

Le D_LATCH n’est pas qu’un exercice scolaire ; c’est un composant omniprésent dans l’architecture des appareils quotidiens.

1. Registres de pipeline de processeur

Les pipelines placent un état entre les étages afin que différentes instructions puissent occuper simultanément des étapes distinctes. Selon la méthode d’horloge, ces frontières emploient des bascules déclenchées sur front ou des phases de latch alternées. Les pipelines fondés sur des latchs peuvent emprunter du temps à travers une frontière, mais exigent une maîtrise rigoureuse de la transparence, du non-recouvrement et du timing de hold.

2. Démultiplexage d’adresse — exemple de l’Intel 8086

Pour économiser des broches physiques, les premiers microprocesseurs comme les Intel 8085 et 8086 utilisaient un bus adresse/données multiplexé. Pendant une partie du cycle machine, les broches portaient une adresse mémoire ; pendant une autre, elles transportaient les données.

Les ingénieurs employaient un D_LATCH externe, tel que le célèbre latch transparent octal 74LS373, pour « démultiplexer » ces signaux. Le processeur plaçait l’adresse sur le bus et envoyait une impulsion nommée ALE — Address Latch Enable. Le D_LATCH capturait l’adresse et la maintenait pour les circuits mémoire, libérant les broches du processeur afin d’envoyer ou de recevoir les données. Sans D_LATCH, le processeur aurait nécessité deux fois plus de broches, le rendant plus grand et bien plus coûteux.

Modèle de latch D avec oscilloscope

Construire le D_LATCH dans digisim.io

La théorie est indispensable, mais l’intuition naît du câblage. La construction suivante emploie deux portes AND, deux NOR et une NOT.

Construction pas à pas

  1. Placez les portes : faites glisser deux AND, deux NOR et une NOT sur le canevas.
  2. Placez les entrées : ajoutez deux composants INPUT_SWITCH. Nommez l’un « Data » et l’autre « Enable ».
  3. Logique d’entrée :
  • Reliez « Data » à la porte AND supérieure.
  • Reliez « Data » à la porte NOT, puis sa sortie à la porte AND inférieure.
  • Reliez « Enable » à la seconde entrée des deux portes AND.
  1. Cœur de mémoire :
  • Reliez la sortie de la porte AND supérieure à l’entrée d’une porte NOR.
  • Reliez la sortie de la porte AND inférieure à l’entrée de la seconde NOR.
  • Couplage croisé : voici le mécanisme essentiel. Reliez la sortie de la NOR supérieure à l’entrée de la NOR inférieure. Reliez la sortie de la NOR inférieure à l’entrée de la NOR supérieure.
  1. Sortie : reliez un OUTPUT_LIGHT à la sortie de la NOR inférieure. Il s’agit de Q.

L’expérience SimCast

La fonction SimCast de digisim.io montre la propagation des signaux au ralenti. Regardez « Enable » jouer le rôle de gardien : un niveau HIGH sur Data atteint les portes AND d’entrée, mais s’y arrête tant qu’Enable ne passe pas lui aussi à HIGH.

Sujets associés dans le parcours

En poursuivant votre exploration de la logique numérique dans digisim.io, les sujets suivants approfondiront vos connaissances.

Le D_LATCH occupe une place charnière dans notre parcours structuré. Il marque le passage de « ce qui se produit maintenant » à « ce qui s’est produit auparavant ».

Conclusion : le premier pas vers la mémoire

Le latch D transforme une rétroaction bistable en stockage contrôlé et sensible au niveau. Il empêche l’entrée D ordinaire de demander simultanément set et reset, tout en laissant la transparence et le timing du front de fermeture au cœur de la conception.

Poursuivez avec la bascule D pour voir comment un stockage déclenché sur front modifie l’interface, ou ouvrez la référence du composant latch D.

Transformez l’idée en un circuit fonctionnel.