Module 3 — La mémoire : bascules, registres, compteurs

Jusqu'ici tes circuits oubliaient tout. On va leur apprendre à se souvenir.

3.1 — Le problème

Ton additionneur du Module 1 est combinatoire : change les entrées, la sortie change aussitôt. Il ne se souvient de rien. Or un processeur doit mémoriser : le résultat du calcul précédent, où il en est dans le programme… Il faut des circuits séquentiels — dont la sortie dépend aussi du passé.

L'astuce fondatrice : reboucler la sortie d'une porte sur son entrée. Le circuit se « verrouille » alors dans un état stable — il retient un bit. C'est le principe du verrou (latch), construit avec… 2 portes NOR ou NAND. Encore elles !

3.2 — L'horloge : le métronome de la puce

Des millions de circuits qui se mettent à jour n'importe quand = chaos. La solution : un signal carré qui bat la mesure, l'horloge (clock) :

clk :  ___╱▔▔▔╲___╱▔▔▔╲___╱▔▔▔╲___
          ↑ front montant = tout le monde se met à jour MAINTENANT

« 3,5 GHz » = 3,5 milliards de fronts montants par seconde. À chaque front, tous les éléments mémoire de la puce capturent leur nouvelle valeur en même temps. Entre deux fronts, la logique combinatoire (tes additionneurs) a le temps de calculer.

3.3 — La bascule D : la cellule mémoire de base

La bascule D (D flip-flop) a une règle d'or : la sortie Q copie l'entrée D uniquement au front montant de l'horloge. Le reste du temps, Q garde sa valeur, quoi que fasse D. C'est 1 bit de mémoire synchronisée.

Simulateur : bascule D

Change D, observe que Q ne bouge PAS. Puis envoie un front d'horloge : Q capture D. C'est LE comportement à comprendre dans ce module.

D = 0
bascule D D clk Q
Q = 0

Chronogramme : D (bleu), clk (rose), Q (jaune) — exactement ce qu'affiche GTKWave pour les vrais ingénieurs.

3.4 — Registre & compteur : assembler les bascules

Un registre de 4 bits = 4 bascules D côte à côte, partageant la même horloge. C'est ainsi que ton CPU stockera ses nombres. Et si on branche un registre sur un additionneur qui fait +1, dont la sortie revient dans le registre… on obtient un compteur : à chaque front d'horloge, la valeur augmente de 1.

En Verilog, voici ta première logique séquentielle :

module compteur (input clk, output reg [3:0] q);
  always @(posedge clk)   // "à chaque front montant de clk"
    q <= q + 1;            // capture la nouvelle valeur
endmodule

Simulateur : compteur 4 bits

Envoie des fronts d'horloge et regarde le compteur s'incrémenter — en binaire, en décimal, et sur le chronogramme. Que se passe-t-il après 15 ?

q = 0000 = 0

Observe : q0 bat à chaque front, q1 deux fois moins vite, q2 quatre fois moins vite… un compteur est un diviseur de fréquence !

💡 Tu as maintenant TOUTES les briques d'un processeur : la logique qui calcule (Modules 1-2) et la logique qui se souvient (Module 3). Le Module 4 les assemble en CPU. Le « PC » (program counter) qui pointe l'instruction courante ? C'est juste… un compteur. Celui que tu viens de manipuler.

3.5 — Vérifie tes connaissances

Quiz du module

1. Quand la sortie Q d'une bascule D change-t-elle ?

2. Un registre 8 bits, c'est :

3. Que signifie always @(posedge clk) en Verilog ?

4. Un compteur 4 bits arrivé à 1111 (15) reçoit un front d'horloge. Il passe à :

Réponds juste aux 4 questions du quiz pour débloquer.

← Module 2 Module 4 : le mini-CPU →