Registre

Un registre est un circuit qui permet de mémoriser plusieurs bits simultanément. Typiquement, on construit un registre en utilisant $N$ bascules D qui seront synchronisées sur le même signal d’horloge.

Si ces bascules D possèdent une entrée de validation $E$, elles seront également reliées ensemble pour que toutes les bascules se mettent à jour sur les mêmes fronts d’horloge.

La figure ci-dessous représente un registre de 4 bits, son symbole à gauche et la structure interne à droite.

Registre à décalage

Dans une période du signal d’horloge, la valeur de la sortie Q est égale à la valeur que son entrée D avait au front d’horloge précédent. Si D ne change pas plus d’une fois pendant chaque période d’horloge, la sortie Q suit les variations de D, mais avec un retard. Un exemple de scénario est représenté sur ce chronogramme :

En mettant en cascade plusieurs bascules, chacune va introduire son propre retard. Ainsi, la sortie Q de la $N$^ième bascule reproduit l’entrée D de la première bascule avec $N$ fronts d’horloge de retard. Le schéma et le chronogramme ci-dessous représentent la structure et le comportement d’un circuit composé de trois bascules en cascade.

Le circuit que nous venons de représenter s’appelle un registre à décalage. Il doit son nom au fait que la valeur du registre – c’est-à-dire le vecteur formé par les valeurs des sorties Q – se décale d’un bit à chaque front d’horloge. Ce registre est dit à chargement série, c’est-à-dire que pour écrire une valeur dans les trois bascules, il faut présenter les bits un par un sur l’entrée $D_0$ et attendre une période d’horloge entre deux bits successifs.

Dans un registre à décalage à chargement parallèle, il est possible d’écrire dans toutes les bascules simultanément. Une entrée de commande permet de sélectionner le mode chargement ou le mode décalage. Dans l’exemple représenté ci-dessous, ce rôle est joué par l’entrée $LOAD$ :

• Si $LOAD$ vaut 1, au front d’horloge, les trois bascules mémorisent les valeurs de $D_0$, $D_1$ et $D_2$.
• Si $LOAD$ vaut 0, à chaque front d’horloge, les valeurs de $Q_0$ et $Q_1$ se décalent en $Q_1$ et $Q_2$ tandis que $Q_0$ est mis à zéro.

Compteur synchrone

Un compteur est un circuit logique qui produit une séquence prédéfinie de valeurs entières au cours du temps, au rythme d’un signal d’horloge. Ces valeurs entières sont représentées en binaire sur un nombre de bits fixé.

Dans le cas le plus fréquent, on utilise un compteur pour produire une séquence d’entiers dans l’ordre croissant en partant de zéro. On parle de compteur modulo N lorsque le compteur compte jusqu’à une valeur N-1 et revient à zéro ensuite. Un décompteur est un circuit qui produit la même séquence dans l’ordre décroissant.

Le fonctionnement d’un compteur synchrone peut être décrit de la manière suivante :

• Entre les fronts d’horloge, le compteur calcule sa valeur suivante en fonction de sa valeur courante.
• À chaque front d’horloge, le compteur met à jour sa valeur courante.

Exemple

Construisons un compteur modulo 6. Nous noterons $k$ sa valeur courante. La valeur suivante calculée par le circuit sera notée $k^*$. Voici un algorithme qui détaille ce calcul :

répéter
    si k = 5 alors
        k* ← 0
    sinon
        k* ← k + 1
    fin si
fin répéter

La boucle répéter est là pour rappeler qu’un circuit logique est en permanence à l’écoute de ses entrées et recalcule ses sorties dès qu’il détecte un changement. Ici, dès que $k$ change, une nouvelle valeur de $k^*$ est automatiquement calculée.

La valeur courante du compteur sera mise à jour à chaque front montant d’un signal d’horloge que nous nommerons $clk$. $k$ devra rester stable entre deux fronts d’horloge pour que le calcul de $k^*$ donne un résultat correct. Nous souhaitons également pouvoir remettre $k$ à zéro dès qu’une commande $reset$ est active.

répéter
    si reset = 1 alors
        k ← 0
    sinon, si front-montant(clk) alors
        k ← k*
    fin si
fin répéter

À partir de ces algorithmes, nous pouvons commencer à proposer la structure d’un circuit. Tout d’abord, nous représenterons les valeurs de $k$ et $k^*$ en binaire sur trois bits. Le calcul de $k^*$ utilisera les composants suivants :

• un additionneur pour calculer $k + 1$,
• un comparateur pour vérifier si $k = 5$,
• un multiplexeur pour sélectionner la valeur à affecter à $k^*$ (si-alors-sinon),
• un registre pour mettre à jour $k$ sur les fronts d’horloge et le maintenir entre les fronts ; ce registre possédera une entrée de remise à zéro asynchrone.

Pour aller plus loin, nous pouvons proposer une version plus légère de ce circuit. En effet, le calcul de $k^*$ peut être réécrit sous la forme d’une table de vérité :

À partir de cette table de vérité, nous proposons les équations suivantes :

Le chronogramme ci-dessous représente un scénario de fonctionnement de ce compteur. Au démarrage, nous faisons l’hypothèse que le compteur est à zéro. À chaque front d’horloge (en orange), la valeur courante $(k_2, k_1, k_0)$ est mise à jour. Cette mise à jour déclenche le calcul de la valeur suivante $(k_2^*, k_1^*, k_0^*)$.

Ce calcul n’est pas instantané : le chronogramme représente en violet la durée pendant laquelle les valeurs binaires traversent les portes logiques jusqu’à produire une valeur stable en $k_2^*$, $k_1^*$ et $k_0^*$. Pendant cette durée, ces trois signaux peuvent prendre des valeurs transitoires qui sont représentées par les zones hachurées. Pour ne pas surcharger le dessin, nous avons supposé que les trois signaux mettent autant de temps à se stabiliser mais ce n’est pas forcément le cas.

Le chronogramme peut devenir difficile à lire lorsque le circuit contient des vecteurs avec un grand nombre de bits. Dans ce cas, il est d’usage de regrouper tous les bits d’un vecteur sur une seule ligne. Si ce vecteur représente un nombre entier, le chronogramme sera plus lisible en représentant ce nombre en décimal ou en hexadécimal.