Les bascules (RS, JK, D et T)
Les bascules, appelées aussi flip-flops en anglais sont des circuits logiques séquentiels capables de mémoriser une information binaire élémentaire; soit la valeur 0 ou la valeur 1. Ce composant est l'élément de base des registres, des compteurs numériques, des mémoires, etc. Ce composant est aussi appelé circuit bistable puisqu'il ne peut prendre que deux états logiques.
L'état d'une bascule, représenté par la valeur à sa sortie Q, peut être modifié en agissant sur une ou plusieurs entrées permettant ainsi de mémoriser ou modifier la valeur binaire déjà en mémoire. Ainsi, la valeur à la sortie de ce composant dépend de la valeur précédente et de la valeur à l'une ou plusieurs entrées, ce qui définit son comportement séquentiel.
C'est compliqué ? Absolument pas, plus simplement, une bascule est un composant qui conserve son état précédent jusqu'à la prochaine demande d'effacement ou de changement reçue à travers l'une de ces entrées.
Bascule asynchrone ou synchrone ?
Il existe des bascules asynchrones comme il existe des bascules synchrones. C'est quoi la différence ? Une bascule asynchrone, non asservie à un signal d'horloge, est une bascule qui change d'état de sa sortie lorsqu'elle reçoit la demande, appelée aussi le signal binaire, à l'une de ses entrées. Alors qu'une bascule synchrone ne change l'état de sa sortie que lorsqu'elle reçoit la demande à l'une de ses entrées mais aussi quand le signal de l'horloge H (appelé aussi CLK) change d'état soit sur :
- Le signal du front montant du signal ; soit quand le signal de notre horloge change d'état du niveau 0 vers le niveau 1 (L'image a ci-dessous nous montre cela)
- Le signal du front descendant ; soit quand le signal de l'horloge change d'état de la valeur 1 binaire vers le niveau 0 (L'image b ci-dessous nous montre cela)
![]() |
![]() |
| a. Signal horloge (CLK) - Front montant | b. Signal horloge (CLK) - Front descendant |
Dans la suite de ce cours, nous allons détailler les quatre types fondamentaux de bascules (flip-flops) :
- La bascule RS (RS pour l'abréviation des deux mots Reset–Set en anglais)
- La bascule JK (JK pour l'abréviation des deux mots Jump et Kill en anglais)
- La bascule D (D pour l'abréviation Delay en anglais)
- La bascule T (T pour l'abréviation du mot Toggle en anglais)
Ainsi, ces quatre bascules sont les éléments fondamentaux de la logique séquentielle. C'est grâce à ces composants que nous pouvons modéliser et créer des compteurs numériques, des registres et mémoires.
La bascule RS
La bascule RS est la forme la plus simple de la plus petite unité de mémoire, représentant la forme la plus simple des bascules en logique séquentielle. Elle dispose de deux entrées nommées \( S \) pour Set et \( R \) pour Reset et deux sorties nommées \( Q \) et \( \overline{Q} \).
Entrées et symbole
Dans sa forme asynchrone (ne disposant pas d'une entrée d'horloge nommée H ou CLK), ces deux entrées nous permettent :
- Entrée \( S \) pour Set : activer la bascule pour mémoriser la valeur 1 binaire.
- Entrée \( R \) pour Reset : effacer la valeur binaire stockée dans la mémoire de la bascule. Donc le 0 binaire à la sortie.
Pour la forme synchrone, l'écriture et l'effacement de la mémoire interne de cette bascule se réalisent au moment du front montant ou descendant en fonction de la configuration de la bascule.
Les deux symboles de cette bascule RS sont modélisées ci-dessous (à gauche la bascule RS asynchrone et à droite la bascule RS synchrone à enclenchement sur front montant) :
![]() |
![]() |
| Bascule RS asynchrone | Bascule RS synchrone (front montant) |
Pour le symbole de la bascule RS à enclenchement sur front descendant, son symbole est modélisé comme suit :

Bascule RS synchrone (front descendant)
Principe de fonctionnement
La bascule RS fonctionne suivant le principe décrit ci-dessous. La sortie \( Q \) et \( \overline{Q} \) dépendent de la valeur à l'entrée de \( S \) ou \( R \) et de la valeur mémorisée telle que
- Quand S = 1, la bascule est mise à 1; soit donc la sortie \( Q = 1 \) et \( \overline{Q} = 0 \)
- Quand R = 1, elle est remise à 0; soit donc la sortie \( Q = 0 \) et \( \overline{Q} = 1\)
- Quand S = R = 0, la bascule mémorise la valeur précédente et la sortie \( Q_{n} = Q_{n-1} \) et \( \overline{Q_{n}} = \overline{Q_{n-1}}\)
- Quand S = R = 1, cette configuration est interdite et la bascule présente un comportement instable.
Table de vérité
Pour une bascule RS, asynchrone ou synchrone, la table ci-dessous résume sa table de vérité :
| S | R | \( Q \) | \( \overline{Q} \) |
| 0 | 0 | inchangé | inchangé |
| 0 | 1 | 0 | 1 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | indéterminé | indéterminé |
Chronogramme
La bascule RS asynchrone peut être réalisée à l’aide de 4 portes logiques NAND comme le montre le schéma de câblage ci-dessous :

Pour mieux comprendre son mode de fonctionnement de cette bascule RS asynchrone, vous trouverez ci-dessous son chronogramme :

Toutefois, il est également possible de réaliser une bascule RS synchrone avec 4 portes logiques NAND mais juste en câblant autrement notre circuit. Le schéma ci-dessous le démontre :

La bascule JK
La bascule JK est une forme améliorée de la bascule RS, représentant aussi la forme la plus simple des bascules en logique séquentielle mais en éliminant l’état interdit de cette dernière. Elle dispose aussi de deux entrées nommées \( J \) pour Jump et \( K \) pour Kill et deux sorties complémentaires \( Q \) et \( \overline{Q} \).
Entrées et symbole
Dans sa forme asynchrone, la bascule JK n'existe pas vraiment et nécessite une horloge H (appelée aussi CLK). Cette bascule est dotée d'une entrée d'horloge H (appelée aussi CLK). Elle dispose donc de trois entrées nous permettant :
- Entrée \( J \) pour Jump: sauter ou activer la bascule à la valeur 1 binaire.
- Entrée \( K \) pour Kill : remettre la bascule à la valeur binaire 0.
- Entrée \( H \) : l'horloge de synchronisation (appelée aussi CLK pour clock en anglais)
Le symbole de cette bascule JK est comme suit :
![]() |
![]() |
| Bascule JK (front montant) | Bascule JK (front descendant) |
Dans le marché, nous retrouvons cette bascule dans un circuit intégré encapsulant 2 bascules JK sous la référence 7476. Pour exemple, vous trouverez ci-dessous une image de ce circuit sous la référence 74LS76 :

Principe de fonctionnement
La bascule JK fonctionne comme une bascule RS à l'exception qu'elle nécessite une horloge et corrige l'état \( J = K = 1 \). Ce principe de fonctionnement est décrit ci-dessous. La sortie \( Q \) et \( \overline{Q} \) dépendent de la valeur à l'entrée de \( J \) ou \( K \) et de la valeur mémorisée telle que :
- Quand J = 1 : la bascule est mise à 1; soit donc la sortie \( Q = 1 \) et \( \overline{Q} = 0 \)
- Quand K = 1 : elle est remise à 0; soit donc la sortie \( Q = 0 \) et \( \overline{Q} = 1\)
- Quand J = K = 0, la bascule mémorise la valeur précédente et la sortie \( Q_{n} = Q_{n-1} \) et \( \overline{Q_{n}} = \overline{Q_{n-1}}\)
- Quand J = K = 1, la bascule change d'état à chaque front signal d'horloge (soit au front montant, soit au front descendant)
Table de vérité
Pour une bascule JK, la table ci-dessous résume sa table de vérité :
| J | K | \( Q \) | \( \overline{Q} \) |
| 0 | 0 | inchangé | inchangé |
| 0 | 1 | 0 | 1 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | \( \overline{Q} \) | \( Q \) |
Chronogramme
La bascule JK peut être également réalisée à partir de 4 portes logiques NAND comme nous le montre le schéma ci-dessous :

Pour comprendre son mode de fonctionnement, en supposant qu'elle opère sur le front montant du signal de l'horloge, vous trouverez ci-dessous un exemple de chronogramme d'une bascule JK :

La bascule D
La bascule D, pour l'abréviation Data, est une forme simplifié de la bascule RS ou la bascule JK puisqu'elle ne comporte qu'une seule entrée nommée \( D \) mais comme toute bascule deux sorties complémentaires \( Q \) et \( \overline{Q} \). Cette bascule est idéale pour réaliser des registres, des blocs de mémoire, etc.
Entrées et symbole
La bascule D n'existe qu'en forme synchrone et nécessite une horloge H (appelée aussi CLK) pour qu'elle fonctionne. Ainsi, elle ne dispose qu'une seule entrée et deux sorties telles que :
- Entrée \( D \) pour Data: elle stocke la valeur 0 quand elle reçoit 0 à son entrée et 1 quand elle reçoit la valeur 1.
- Entrée \( H \) : l'horloge de synchronisation (appelée aussi CLK pour clock en anglais)
Le symbole de cette bascule D est comme suit :
![]() |
![]() |
| Bascule D (front montant) | Bascule D (front descendant) |
Pour une bascule D, nous la retrouvons dans le circuit intégré encapsulant 2 bascules D sous la référence 7474. Comme exemple, vous trouverez ci-dessous une image de ce circuit dont la référence est 74LS74 :

Principe de fonctionnement
La bascule D fonctionne comme une unité de mémoire synchronisé à un signal d'horloge. Quand le front actif de l'horloge arrive, la bascule copie la valeur reçue à son entrée \( D \) et la recopie à sa sortie \( Q \). Autrement dit, la sortie suit l'entrée au bon moment; ce moment est le front montant ou le front descendant du signal de l'horloge telle que :
- Quand D = 0 : la bascule est mise à 1 au prochain front actif du signal de l'horloge; soit donc la sortie \( Q = 0 \) et \( \overline{Q} = 1 \)
- Quand D = 1 : la bascule est mise à 0 au prochain front actif du signal de l'horloge; soit donc la sortie \( Q = 1 \) et \( \overline{Q} = 0 \)
Table de vérité
Pour une bascule D, la table ci-dessous résume sa table de vérité :
| D | \( Q \) | \( \overline{Q} \) |
| 0 | 0 | 1 |
| 1 | 1 | 0 |
Chronogramme
Pour une bascule D, à enclenchement sur le front montant du signal de l'horloge, le chronogramme ci-dessous nous démontre un exemple de son mode de fonctionnement :

Pour réaliser une bascule D, il est possible de la modéliser à partir d'une bascule RS synchrone ou d'une bascule JK. Nous vous présentons les deux montages possibles ci-dessous :
![]() |
![]() |
| Bascule D à partir d'une bascule RS synchrone | Bascule D à partir d'une bascule JK |
La bascule T
La bascule T, pour l'abréviation toggle en anglais, est un système séquentiel synchrone qui change d’état; soit de 0 à 1 ou 1 à 0, à chaque front actif de l'horloge. La bascule T dispose, comme les autres bascules, deux sorties \( Q \) et \( \overline{Q} \).
Entrées et symbole
Comme le décrit son principe de fonctionnement, la bascule T n'existe qu'en version synchrone et nécessite une horloge H (apelée aussi CLK) pour qu'elle fonctionne et donc elle ne dispose qu'une seule entrée qu'on appelle aussi T et une entrée H pour son horloge telles que :
- Entrée \( T \) pour Toggle : si cette entrée est activée \(T = 1 \), la sortie de la bacule change d'état à chaque front actif de l'horloge.
- Entrée \( H \) : l'horloge de synchronisation pour faire fonctionner la bascule; appelée aussi CLK pour clock en anglais.
Le symbole de cette bascule T est comme suit :
![]() |
![]() |
| Bascule T (front montant) | Bascule T (front descendant) |
Principe de fonctionnement
La bascule T fonctionne comme une unité de mémoire dont la sortie est toujours le complément de son état précédent. Autrement dit, \( Q_{n+1} = \overline{Q_{n}} \).
Table de vérité
Pour une bascule T, la table ci-dessous résume sa table de vérité :
| T | \( Q \) | \( \overline{Q} \) |
| 0 | \( Q \) : Pas de changement | \( \overline{Q} \) : Pas de changement |
| 1 | \( \overline{Q_{n-1}} \) | \( Q_{n-1} \) |
Chronogramme
Et pour une bascule T, même chose à enclenchement sur front montant de notre signal électrique, le chronogramme ci-dessous nous présente son comportement dans le temps :

Et pour réaliser une bascule T, comme la bascule D, il est aussi possible de la réaliser à partir d'une bascule JK comme à partir d'une bascule D. Nous vous présentons ces deux possibilités ci-dessous :
![]() |
![]() |
| Bascule T à partir d'une bascule JK | Bascule T à partir d'une bascule D |













