Circuits séquentiels

I : Compteurs / Décompteurs *

II : Registres, Mémoires *

III : Automates *

Une fonction importante en logique séquentielle est la fonction mémoire. Dans un système informatique, quel que soit sa forme, la mémoire est primordiale.

Nous allons voir un type particulier de mémoire, les registres, ou mémoire statique.

La cellule de base de tous les types de registres est la mémoire statique 1 bit :

Sur un front montant (ou descendant) de l’entrée de contrôle C, la mémoire prend la valeur présentée en entrée et la maintient jusqu’au prochain front montant (descendant) de C.

Il peut y avoir présents des entrées Set et Reset pour forcer à 0 ou à 1 la cellule mémoire.

L’entrée de contrôle (ou horloge) C est ici appelée bit d’écriture ; en effet, c’est un front montant (descendant) sur cette ligne qui déclenche une écriture dans la cellule mémoire. La lecture est quand à elle permanente, l’état " interne " étant présent en permanence sur la ligne de sortie Q. Il est à noter que la sortie /Q n’est pas utilisée.

On peut également trouver des mémoires avec une entrée de contrôle par niveau (au lieu de par front) mais c’est plus rare. Le principe est cependant le même, mais l’opération d’écriture se réalise durant toute la durée du niveau haut (ou bas) de C. Bien évidemment, l’entrée D ne doit pas changer pendant ce temps !

Un registre est un ensemble de cellules mémoire de base.

Il est de faible capacité (4, 8, 16, 64 bits) mais de temps d'accès très faible (rapide, quelques ns en général).

Les données peuvent être écrites/lues en même temps (parallèle) ou une après l'autre (série).

Souvent une structure à entrées/sorties 3 états (haute impédance) est nécessaire pour l'interfaçage avec un bus.

Le nombre de bits du registre correspond au nombre de cellules mémoire (bascules D) du registre.

Notons que toutes les entrées d'horloge (C) des cellules sont reliées. (ligne d’écriture)

Tous les bits sont lus et écrits en même temps (en parallèle).

Par exemple, pour un registre parallèle 4 bits, le symbole et le schéma sont :

Un registre parallèle est très rapide, mais pour un grand nombre de bits demande beaucoup de connections.

Il est souvent fourni avec des entrées de type " 3 états " pour une connexion avec un bus.

Les bits sont lus/écrits les uns après les autres, et décalés.

Exemple de réalisation :

En 4 cycles d’horloge, un mot de 4 bits est mémorisé.

Attention : le décalage se produit également pour la lecture : si les bits ne sont pas " réintroduits " à l’entrée, l’information est perdue !

Le chronogramme de fonctionnement est le suivant (on veut mémoriser le mot %1011) :

On peut imaginer des registres mixtes, donc on peut écrire en parallèle et lire en série, ou vice-versa, ou qui offrent les deux possibilités " au choix ".

On peut également exploiter d’éventuelles entrées de Set ou Reset sur les bascules D.

En logique séquentielle, il est fondamental de pouvoir compter, par exemple pour attendre un temps précis, pour compter un nombre d’état....

Observons le montage suivant, réalisé à partir d’une bascule D à contrôle par front :

A chaque front montant de C, la sortie Q prend la valeur de D, donc ici celle de /Q. Cette bascule change donc d’état à chaque front montant de C.

Ce qui nous donne le chronogramme suivant :

On remarque bien que les signaux Q et /Q sont de fréquence deux fois moindre que le signal C. On a donc fabriqué un diviseur de fréquence par 2.

Son graphe des états est :

On choisit Q comme état interne de la bascule.

En reliant en série plusieurs diviseurs par 2, on peut obtenir des diviseurs par 4,8...2ⁿ , chaque bascule D divisant sa fréquence d’entrée par 2.

Observons le montage et le chronogramme d’un diviseur par 8 (3 bascules) :

On remarque qu’on l’on a bien un décompteur 3 bits, de 0 à 7. (la ligne de remise à zéro est facultative).

Son graphe des états est (on choisit la valeur du décompteur comme état : )

De manière générale, pour construire un décompteur de 0 à 2ⁿ –1 (n bits), on relie n diviseurs par 2 (on a donc besoin de 2ⁿ bascules D). Les entrées D sont reliées aux sorties /Q, et l’entrée d’horloge de chaque bascule est la sortie Q de la bascule précédente.

Nous avons vu comment construire un décompteur, mais bien souvent un compteur serait plus utile !

Observons le même montage, mais en visualisant les sorties /Q au lieu des sorties Q :

On a bien maintenant un compteur à 8 (0à 7).

Tous les compteurs possèdent un cycle de comptage qui est une puissance de 2, de par leur structure même. Mais comment faire si l’on désire un compteur à 10 par exemple ? 

La solution est de construire un compteur à cycle complet normal, mais de le forcer à 0 au bon moment.

Par exemple, pour un compteur décade (0à 9) :

On utilise un compteur 4 bits, qui lui compte de 0 à 15. Il faut donc forcer à 0 toutes les bascules du compteur aussitôt le nombre 10.

En binaire 4 bits, 10=%1010, donc on obtient l’expression du signal Reset :

Ce qui nous donne un montage tel que celui-ci (on a bien sûr besoin de bascules D avec une entrée Reset.) :

Le chronogramme de fonctionnement est le suivant :

On remarque que la durée du signal R est très courte (elle est ici exagérée) puisque son action remet instantanément toutes les bascules D à zéro.

Le graphe des états est :

On voit bien sur le graphe que l’état 10 est " fugitif " puisque dès qu’il est atteint, les bascules sont remises à zéro. Ceci peut entraîner un problème : le signal de Reset change d’état dès qu’une des bascules revient à zéro. Il est donc possible qu’une ou plusieurs bascules n’aient pas le temps de changer d’état, et donc on ne revient pas à l’état 0, mais à un état indéterminé !

Pour éviter ce problème, il faut utiliser des bascules maître/esclave.

On pourrait de même imaginer un compteur comptant de 2 à 7 (au lieu de 0 à 7...). Il suffit, de la même manière, de forcer les bascules à une certaine valeur (avec les S et R) lorsqu’une certaine combinaison se présente.

Les mêmes modifications sont possibles sur les décompteurs.

Il peut être utile de concevoir des compteurs/décompteurs avec des bascules JK, notamment car en général les bascules D ne sont pas pourvues de Set/Reset.

Avec une JK, on inverse l’état des sorties si J=K=1 ; donc, il suffit de câbler une JK par bit de compteur de cette façon ; les sorties sont reliés aux entrées d’horloge, comme pour une D.

le fonctionnement est exactement le même.

Les compteurs que l’on vient de voir sont dits asynchrones, car chaque " horloge " est différente d’une bascule à l’autre (puisqu’elle est la sortie de la bascule précédente). Mais lorsque la fréquence de l’horloge est élevée, le temps de propagation n’est plus négligeable et peut introduire des retards, voire une dé-synchronisation de l’horloge.

Pour ses fréquences élevées, on doit utiliser des compteurs dits synchrones, dont les entrées d’horloge (C) sont toutes reliées à l’horloge du système. Elles changent donc d’état simultanément. Bien sûr, le schéma est un peu plus compliqué.

On ne peut plus utiliser le principe du diviseur de fréquence, on utilise donc des bascules JK, et une partie de logique combinatoire pour commander les bits J et K en fonction des sorties partielles. Chacune des bascules JK est câblée en bascule ‘T’, et doit changer d’état quand toutes celles qui la précédente sont à l’état ‘1’.

Par exemple, un compteur synchrone 3 bits :

Pour réaliser un compteur synchrone modulo n (et ce, même si n n’est pas une puissance de 2), on prend autant de bascules JK que pour un compteur asynchrone (3 pour un compteur modulo 5,6,7,8 , 4 pour un compteur modulo 9-16) et on relie toutes les horloges entre elles. Il reste ensuite à determiner les expressions algébriques des entrées J et K. Pour cela, on dresse la table de vérité du compteur (ou décompteur) et on synthétise (par ex. Par Tableaux de Karnaugh) les équations de J et K.

Par exemple, pour réaliser un compteur modulo 3 (0-1-2-0-1-2....) :

Il nous faut 2 bascules, puisque une seule ne suffit pas (2¹=2<3, alors que 2²=4> 3).

Dressons la table de vérité d’un tel compteur :

On écrit donc les tableaux de Karnaugh pour chaque J et chaque K :

J₁=Q₀

K₁ = 1

J₀ = /Q₁

K₀ = 1

On peut donc construire complètement le compteur modulo 3. Contrairement au compteur asynchrone, le problème de l’état " fugitif " et du Reset ne se pose pas, le compteur étant par construction, modulo n.

On appelle automate un opérateur séquentiel dont l’état et les sorties futures sont fonction des entrées et de l’état présent de l’automate. Un automate utilise des bascules non transparentes (par ex. D à contrôle par front, bascules maître/esclave) pour mémoriser l’état présent et des opérateurs combinatoires pour générer les sorties et l’état futur.

Un automate est synchrone lorsque le passage de l’état présent à l’état futur à lieu sur la transition d’un signal d’horloge commun à toutes les bascules de l’automate. Il est asynchrone sinon.

Il y a deux types d’automates :

• L’automate de Moore : l’état futur est fonction de l’état présent et des entrées ; les sorties sont fonction de l’état présent.
• L’automate de Mealy : l’ état futur est fonction de l’état présent et des entrées ; les sorties sont fonction de l’état présent et des entrées.

Il y a complète équivalence entre les deux modèles : tout automate de Meary peut être transformé en automate de Moore et réciproquement. L’automate de Meary a toujours moins d’ états que l’automate de Moore correspondant.

Un chariot doit amener un chargement à l’atelier sur demande d’un opérateur (DO). Il se déplace le long d’un rail (par la commande de moteur AV) muni d’un capteur de fin de course FC1. Une fois arrivé, il verse (commande V) son chargement jusqu’à être complètement vide (capteur VI). Il retourne ensuite au magasin (par la commande de moteur AR) jusqu’au capteur de fin de course FC0, où il est rempli. Le cycle peut alors recommencer.

L’automate devra gérer le déplacement et la vidange du chariot.

Ses entrées sont :

DO : demande de l’opérateur

FC1 : arrivée à l’atelier

VI : chariot vide

FC0 : arrivée au magasin

Ses sorties sont :

AV : avance du chariot

AR : recul du chariot

V : vidange du chariot

Le système comporte 4 états, liés à la position du chariot.

Etat 0 : chariot en attente au magasin.

Etat 1 : chariot en déplacement du magasin à l’atelier

Etat 2 : vidange du chariot

Etat 3 : chariot en déplacement de l’atelier au magasin

Son graphe des états est :

On peut réaliser l’automate soit avec des bascules D (codage binaire, il en faut donc 2) ou des bascules JK (codage naturel, il en faut donc 4).

On utilise ici des bascules JK au lieu des bascules D. Il en faut 4 (1 par état).

Une bascule JK est mise à 1 par action sur J, et mise à zéro par action sur K.

On peut donc directement à partir du graphe des états, déterminer les équations de J et de K :

• Sur chaque J, on applique un ET entre la condition d’entrée dans l’état et l’état précédent
• Sur chaque K, on applique le J suivant (ce qui met une bascule 1 remet la précédente à 0)

On voit que suivant ce principe, il n’y a qu’une et une seule bascule JK à l’état 1. Il faut donc qu’au démarrage de l’automate, on force un des états à 1 (initialisation de l’automate). On parle d’état initial. Ici, l’état initial est l’état 0. On utilise donc l’entrée S de la bascule JK0 et les entrées R des autres JK pour initialiser l’automate.

Ce qui nous donne comme équations :

Les équations des sorties en fonction des états sont ici plus simples :

Comme on le voit, la partie combinatoire de cet automate est nettement plus simple que le précédente. Par contre, la partie séquentielle est plus importante. Cette construction n’est pas adaptée à un grand nombre d’états. De plus, elle nécessite une initialisation.