Cours n°8 : Circuits séquentiels


 

I : Compteurs / Décompteurs *

  • I.1 : Diviseur de fréquence *

    I.2 : Décompteur à 2n *

    I.3 : Compteur à 2n *

    I.4 : Compteurs à cycle incomplet *

    I.5 : Compteurs avec bascules JK *

    I.6 : Compteurs asynchrones/synchrones *

  • II : Registres, Mémoires *

  • II.1 : Mémoire 1 bit *

    II.2 : Le registre, généralités. *

    II.3 : Registre parallèle *

    II.4 : Registre série (registre à décalage) *

    II.5 : Registres mixtes *

  • III : Automates *

  • III.1 : Définitions *

    III.2 : Exemple d’automate *

    III.2.a : Cahier des charges *

    III.2.b : Détermination des états *

    III.2.c : Réalisation de l’automate par codage naturel *

  •  


     

    I : Compteurs / Décompteurs

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

     

    I.1 : Diviseur de fréquence

    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 :

    C

    Q

    /Q

    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.

    Le symbole ­ indique un front montant (­ C est à un durant le front montant de C, /(­ C) est son complément) .

     

    Remarque : notion de transparence de la bascule.

    Il est important que la bascule qu’on utilise ainsi (rebouclage d’une sortie sur une entrée) ne soit pas transparente (opaque) : si elle l’est, alors la sortie est directement liée à l’entrée, et dans ce montage amène /Q=D=Q, donc Q=/Q ! ce qui provoque soit des oscillations en sortie, soit un fonctionnement incohérent. Une bascule LATCH D est transparente; on ne peut pas l’utiliser pour ce montage. Les bascules D opaques sont les D maître-esclave, et les D à contrôle par front.

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

     

    I.2 : Décompteur à 2n

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

    C

    Q0

    Q1

    Q2

     

    7

    6 5 4 3 2 1 0  

    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 à 2n –1 (n bits), on relie n diviseurs par 2 (on a donc besoin de 2n 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.

     

    I.3 : Compteur à 2n

    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 :

    C

    /Q0

    /Q1

    /Q2

      7 0 1 2 3 4 5 6 7

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

    Pour un compteur / décompteur n bits, on relie " en série " 2n bascules D câblées en diviseur de fréquence par 2, et on prend les sorties Q pour un décompteur, /Q pour un compteur.

     

    I.4 : Compteurs à cycle incomplet

    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 :

    C

    B0

    B1

    B2

    B3

    R

       

     

    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.

    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.

     

    I.5 : Compteurs avec bascules JK

    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.

     

     

    I.6 : Compteurs asynchrones/synchrones

    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 :

     


    II : Registres, Mémoires

    La deuxième fonction importante en logique combinatoire 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.

     

    II.1 : Mémoire 1 bit

    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 !

     

    II.2 : Le registre, généralités.

    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)

     

    II.3 : Registre parallèle

    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 :

     

    Schéma de réalisation

    Symbole

    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.

     

    II.4 : Registre série (registre à décalage)

    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) :

    C

    Entrée

    Q0

    Q1

    Q2

    Sortie

     

    II.5 : Registres mixtes

    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.

     

     


    III : Automates

     

    III.1 : Définitions

    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) 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 :

    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.

     

    III.2 : Exemple d’automate

    III.2.a : Cahier des charges

    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 recommancer.

    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

    III.2.b : Détermination des états

    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).

    III.2.c : Réalisation de l’automate par codage naturel

    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 :

    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 :

    AV=Q1 AR=Q3 V=Q2

    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.