Écrire un bit sur ordre : le verrou et la mémoire de n bits

La stratégie. On ramène le verrou à la bascule $\overline{S}\overline{R}$ déjà connue : il suffit de lire, pour chaque couple $(E,D)$, l'ordre que les portes de validation lui transmettent. Puis on suit les changements porte par porte, chacun retardé de $t_p$.

1) La table.

Pour $E=0$, les deux portes de validation ont une entrée nulle et sortent 1 : $\overline{S}=\overline{R}=1$, la bascule mémorise, quelle que soit $D$. Pour $E=1$, $\overline{S}=\overline{D}$ et $\overline{R}=D$ : $D=1$ écrit un 1, $D=0$ écrit un 0 ; donc $Q=D$. La combinaison interdite $\overline{S}=\overline{R}=0$ exigerait $D\cdot E=1$ et $\overline{D}\cdot E=1$, donc $D=1$ et $D=0$ à la fois : impossible (en régime établi). C'est tout l'intérêt du montage : une seule entrée de donnée, et l'état interdit disparaît.

2) Le chronogramme. De 0 à 2 µs, $E=0$ : $Q$ garde sa valeur initiale 0, bien que $D$ passe à 1 à 1 µs. Pendant $[2;4]$, $E=1$ : $Q$ recopie $D$, il vaut 1 de 2 à 3 µs puis 0 à partir de 3 µs, quand $D$ retombe. À 4 µs, $E$ retombe alors que $D=0$ : 0 est mémorisé. L'impulsion de $D$ sur $[5;6]$ arrive hors validation : elle est ignorée. Pendant $[7;9]$, $Q$ suit $D$, y compris la brève impulsion de $[7,5;7,8]$ ; à $8,5$ µs, $D$ passe à 1 ; à 9 µs, $E$ retombe alors que $D=1$ : $Q=1$ est mémorisé, et reste à 1 quand $D$ retombe à 10 µs.

Pendant la validation, la sortie suit l'entrée comme à travers une vitre : le verrou est transparent ; il mémorise la valeur de $D$ présente au moment où $E$ retombe. Le revers de cette transparence : tout parasite de $D$ pendant que $E=1$ est recopié en sortie.

3) La durée d'écriture. On prend pour origine la montée de $E$, avec $D=1$ et $\overline{D}=0$ établis. $\overline{S}=\mathrm{NAND}(1,1)$ tombe à 0 en $t_p$ ; $\overline{R}=\mathrm{NAND}(0,1)$ reste à 1. $Q=\mathrm{NAND}(\overline{S},\overline{Q})$ monte en $2t_p$ ; $\overline{Q}=\mathrm{NAND}(1,Q)$ descend en $3t_p$ ; ce n'est qu'alors que la boucle maintient $Q=1$ par elle-même. Si $E$ retombe à l'instant $w$, $\overline{S}$ remonte en $w+t_p$ ; il faut qu'à cet instant $\overline{Q}=0$ soit établi : $w+t_p⩾3t_p$, soit $$w⩾2t_p=20\mathrm{ns}.$$ C'est la même condition que pour un ordre adressé à la bascule seule : un tour de boucle. Si $D$ change au moment où $E$ retombe, la bascule reçoit un ordre trop bref, ou deux ordres contraires à quelques nanosecondes d'intervalle : l'état mémorisé est incertain, et la bascule peut rester un moment indécise, comme une paire d'inverseurs partie de son point milieu (métastabilité). D'où les deux contraintes qu'imposent les fiches techniques : $D$ doit être stable un peu avant la retombée de $E$, et le rester un peu après (temps d'établissement et de maintien, de quelques $t_p$).

4) La mémoire de $n$ bits. Un bit par verrou : un mot de $n$ bits est fait de $n$ verrous côte à côte, chacun avec sa donnée $D_i$, tous commandés par la même validation $E$ ; une impulsion de $E$ écrit le mot d'un coup, et les sorties $Q_i$ le restituent. Pour 8 bits : $8\times 5=40$ portes (quatre NAND et un inverseur par bit). Pour $8192$ bits : plus de $40000$ portes, plus de quoi choisir le mot à écrire (une validation par mot, commandée par l'adresse) ; c'est pourquoi les mémoires statiques réduisent chaque bit à la paire d'inverseurs et aux deux interrupteurs de la cellule étudiée plus haut. Une mémoire de $n$ bits est faite de $n$ bistables ; chacun garde son bit tant qu'il est alimenté, et seulement tant qu'il l'est : la mémoire est volatile.

Ce que l'exercice installe. Réaliser une mémoire à partir d'un bistable : deux portes de validation devant une bascule RS en font un verrou, qui écrit $Q=D$ pendant la validation et garde la dernière valeur quand elle retombe ; l'état interdit devient impossible. Un ordre d'écriture doit durer au moins un tour de boucle, $2t_p$, et la donnée doit être stable autour de la retombée de $E$. Une mémoire de $n$ bits, ce sont $n$ bistables qu'on valide ensemble.