Construction de circuits de portes logiques

Dans la leçon précédente, nous avons découvert les quatre portes logiques de base. Dans cette leçon, nous allons les connecter ensemble pour construire des circuits qui résolvent des problèmes concrets.

Une seule porte logique est comme une vis — sa fonction est limitée à elle seule. Mais en les combinant, on peut construire des fonctions arbitrairement complexes.


Analogie du quotidien : construire un château avec des briques Lego

Imaginez que vous avez quatre couleurs de briques LEGO devant vous :

  • Bloc vert = porte ET: le courant ne circule que lorsque les deux extrémités sont connectées
  • Bloc orange = porte OU: le courant circule lorsqu'au moins une des deux extrémités est connectée
  • Bloc rouge = porte NON: allumé devient éteint, éteint devient allumé
  • Bloc violet = porte XOR: le courant circule lorsque les deux extrémités sont dans des états différents

Que pouvez-vous construire avec ces briques ?

un voteurTrois personnes votent, et la majorité l'emporte. C'est un circuit logique combinatoire typique — il suffit de connecter des portes ET/OU pour le réaliser.

un cadenas à combinaisonLes bonnes touches doivent être enfoncées simultanément pour déverrouiller. Il s'agit essentiellement d'une cascade de portes ET — chaque touche correspond à une entrée, et ce n'est que lorsque toutes les entrées valent 1 que la sortie devient 1.

une alarmeSi un capteur se déclenche, l'alarme retentit. C'est essentiellement une application de portes OU — tant qu'un capteur émet 1, l'alarme sonne.


Logique combinatoire vs logique séquentielle

Avant d'approfondir la construction de circuits, distinguons deux concepts importants :

TypeFonctionnalitésLa sortie dépend deA-t-il une mémoire ?Exemples
Logique combinatoireLa sortie est déterminée uniquement par l'entrée actuellevaleur d'entrée actuellenonAdditionneur, voteur majoritaire, décodeur
Logique séquentielleLa sortie est déterminée par les entrées actuelles + l'état historiqueEntrée actuelle + valeurs précédemment stockéesOuiCompteur, registre, machine d'état

Ce cours se concentre sur la logique combinatoire.La logique séquentielle sera introduite en détail dans le cours 9.

Une façon simple de les distinguer : la logique combinatoire, c'est « ce que vous entrez, je le sors » (comme une fonction mathématique) ; la logique séquentielle, c'est « je me souviens encore de ce que vous avez entré avant » (comme la mémoire humaine).


Méthodologie de construction de circuits : la méthode en trois étapes

Il existe un processus universel en trois étapes pour construire n'importe quel circuit logique combinatoire avec des portes logiques :

  1. Établir la table de véritéÉtape 1 : Listez toutes les combinaisons d'entrées et notez la sortie attendue pour chaque cas.
  2. Écrire l'expression logiqueÉtape 2 : Pour chaque ligne où la sortie vaut 1, écrivez le « terme produit » correspondant (la combinaison AND des entrées), puis reliez tous les termes produits avec OR. C'est ce qu'on appelle la forme « somme de produits ».
  3. Dessiner le schéma du circuit / Écrire le codeÉtape 3 : Traduisez l'expression logique en une connexion de circuit au niveau des portes.

Mettons cette méthode en pratique à travers trois exemples, du plus simple au plus avancé.


Cas 1 : Serrure à mot de passe à deux entrées

ExigencesCas 1 : Concevez un circuit simple de vérification de mot de passe. Il y a deux entrées A et B. Ce n'est que lorsque A=1 et B=1 que la sortie devient 1 (déverrouillé) ; sinon, la sortie est 0 (verrouillé).

Cette exigence correspond en fait simplement à une porte AND. Mais nous pouvons l'utiliser pour démontrer la méthode en trois étapes :

Étape 1 : Table de vérité

ABSortie attendue Y
000 (verrouillé)
010 (verrouillé)
100 (verrouillé)
111 (déverrouillé)

Étape 2 : Expression logique

Seule la dernière ligne a une sortie à 1. Le terme produit correspondant est : A ET B.

Donc : Y = A ET B

Étape 3 : Implémentation du circuit

Vous n'avez besoin que d'une porte ET, avec A et B comme entrées, et Y comme sortie.

Trop simple ? Regardons un exemple plus pratique.


Cas 2 : Voteur à majorité (cas principal)

ExigencesTrois personnes (A, B, C) votent sur une proposition (1 signifie approuver, 0 signifie rejeter). La proposition est adoptée lorsque au moins deux personnes approuvent (sortie 1).

Il s'agit d'un voteur à majorité classique à trois entrées et d'un cas incontournable dans les manuels de circuits numériques.

Étape 1 : Dresser la table de vérité

Trois entrées ont un total de 23= 8 combinaisons :

ABCNombre de voix pourRéussite/échec : YDescription
00000Personne n'est en faveur
00110Seul C approuve
01010Seul B approuve
01121B et C approuvent
10010Seul A approuve
10121A et C approuvent
11021A et B approuvent
11131Adopté à l'unanimité

Étape 2 : Écrire l'expression logique

Trouvez les lignes où la sortie est 1 (lignes 4, 6, 7, 8), et écrivez un terme produit pour chaque ligne :

  • Ligne 4 : NOT(A) AND B AND C
  • Ligne 6 : A AND NOT(B) AND C
  • Ligne 7 : A AND B AND NOT(C)
  • Ligne 8 : A AND B AND C

Utiliser une connexion OR : Y = (NOT(A) AND B AND C) OR (A AND NOT(B) AND C) OR (A AND B AND NOT(C)) OR (A AND B AND C)

Cette expression peut sembler un peu longue, mais logiquement elle est très claire :Y vaut 1 si et seulement si deux ou trois entrées quelconques valent 1。

Étape 3 : Dessiner le schéma du circuit avec SVG

three input linesA B C AND gate 1: A AND B ANDConnect to AND1 AND gate 2: B AND C AND AND gate 3: A AND C AND OR gate (combining the outputs of three AND gates) OR Output line YTagsFigure: Three-input majority voter circuit structure

Trois portes AND vérifient si chacune des trois paires "AB", "BC" et "AC" vaut 11, puis la porte OR agrège les résultats.


Démo interactive : implémentation Python du voteur à la majorité

Exemple

# Voteur à majorité à trois entrées (démo d'exemple)
# Exigence : trois personnes votent ; cela passe (sortie 1) seulement lorsque au moins deux approuvent (1).

# ----- Réutiliser les portes logiques de base du cours 6 -----
def AND(a, b):
    return 1 if a == 1 and b == 1 else 0

def OR(a, b):
    return 1 if a == 1 or b == 1 else 0

def NOT(a):
    return 1 if a == 0 else 0


# ----- Méthode 1 : forme standard somme de produits (SOP) -----
def majority_voter_sop(a, b, c):
    """
Implémentation en somme de produits du voteur majoritaire.
Dérivez directement de la table de vérité : trouvez toutes les lignes où la sortie vaut 1,
Écrivez un terme AND par ligne, puis reliez-les avec OR.
    """

    term1 = AND(AND(NOT(a), b), c)       # ~A·B·C
    term2 = AND(AND(a, NOT(b)), c)       # A·~B·C
    term3 = AND(AND(a, b), NOT(c))       # A·B·~C
    term4 = AND(AND(a, b), c)            # A·B·C
    return OR(OR(term1, term2), OR(term3, term4))


# ----- Méthode 2 : forme simplifiée optimisée -----
def majority_voter_optimized(a, b, c):
    """
Implémentation optimisée du voteur majoritaire : Y = AB + BC + AC.
Cette forme nécessite moins de portes, mais elle est logiquement équivalente à la méthode 1.

Pourquoi est-ce équivalent ?
Après avoir développé la forme SOP de la méthode 1, elle peut être simplifiée à l'aide de la loi d'absorption de l'algèbre de Boole :
    ~A·B·C + A·~B·C + A·B·~C + A·B·C
    = (~A·B·C + A·B·C) + (A·~B·C + A·B·C) + (A·B·~C + A·B·C)
    = B·C·(~A+A) + A·C·(~B+B) + A·B·(~C+C)
    = B·C + A·C + A·B
    """

    return OR(OR(AND(a, b), AND(b, c)), ET(a, c))


# ============================================
# Afficher la table de vérité complète et comparer les deux méthodes
# ============================================
print("=" * 60)
print(Table de vérité du vote majoritaire à trois entrées (démo d'exemple))
print("=" * 60)
print()
print("┌───┬───┬───┬────────┬──────────┬──────────┐")
print(│ A │ B │ C │ Réussi ? │ Méthode SOP │ Méthode d'optimisation │)
print("├───┼───┼───┼────────┼──────────┼──────────┤")
for a in [0, 1]:
    for b in [0, 1]:
        for c in [0, 1]:
            count = a + b + c
            passed = "Réussi" if count >= 2 else "Échoué"
            sop = majority_voter_sop(a, b, c)
            opt = majority_voter_optimized(a, b, c)
            print(f"│ {a} │ {b} │ {c} │ {passed} │ {sop} │ {opt} │")
print("└───┴───┴───┴────────┴──────────┴──────────┘")

# ============================================
# Statistiques d'utilisation des circuits à portes logiques
# ============================================
print("\n" + "=" * 60)
print(" Comparaison du nombre de portes utilisées par les deux méthodes")
print("=" * 60)
print()
print(Méthode 1 (forme complète SOP) :)
print(Portes NON : 3 (~A, ~B, ~C))
print(Portes ET : 4 (quatre termes ET, chacun nécessitant 2 portes ET à deux entrées))
print(Porte OU : 3 (combinaison de quatre termes produits))
print(Total : environ 14 appels de portes de base)
print()
print("Méthode 2 (forme optimisée Y = AB + BC + AC) :")
print(Portes ET : 3 (AB, BC, AC))
print(Porte OU : 2 (combinaison de trois termes produits))
print(" Total : 5 appels de portes de base")
print()
print(Après optimisation, le nombre de portes est réduit d'environ 65% !)
print("C'est la valeur d'ingénierie de la simplification de l'algèbre de Boole.")

Notez le processus de conversion de la table de vérité vers l'expression logique. C'est l'une des compétences clés de la conception de circuits numériques : en voyant une table de vérité, vous pouvez écrire l'expression ; en voyant une expression, vous pouvez dessiner le schéma du circuit. Les trois correspondent un à un.


Cas 3 : comparateur à 1 bit

ExigencesComparez deux nombres binaires de 1 bit A et B. Produisez trois signaux : A>B, A=B, A<B

Il s'agit d'un circuit de base très important — les comparateurs multi-bits et les jugements conditionnels dans les CPU sont des extensions de celui-ci.

Étape 1 : Table de vérité

ABA > BA = BA < B
00010
01001
10100
11010

Étape 2 : Expression logique

Observez la table de vérité :

  • A > B vaut 1 si et seulement si : A=1 AND B=0. Donc : Greater = A AND NOT(B)
  • A = B vaut 1 si et seulement si : A et B sont identiques. Donc : Equal = NOT(A XOR B), ou, autrement dit, Equal = (A AND B) OR (NOT(A) AND NOT(B))
  • A < B vaut 1 si et seulement si : A=0 AND B=1. Par conséquent : Less = NOT(A) AND B

Notez que la détection de A = B est étroitement liée à la porte XOR. Une sortie XOR de 1 signifie "différent" ; en prendre le NOT donne "égal".

Étape 3 : implémentation du code

Exemple

# Comparateur 1 bit (exemple de démonstration)
# Compare deux nombres binaires à 1 bit A et B

def AND(a, b):
    return 1 if a == 1 and b == 1 else 0

def OR(a, b):
    return 1 if a == 1 or b == 1 else 0

def NOT(a):
    return 1 if a == 0 else 0


def one_bit_comparator(a, b):
    """
Comparateur 1 bit : compare A et B.
Renvoie un tuple (Greater, Equal, Less).
    """

    greater = AND(a, NOT(b))   # A > B : A=1 et B=0
    less = AND(NOT(a), b)      # A < B : A=0 et B=1
    # A = B : ni supérieur ni inférieur
    # Équivalent à NOT(A XOR B), ici nous utilisons une autre implémentation
    equal = AND(NOT(greater), NOT(less))
    return (greater, equal, less)


# Afficher la table de vérité
print("=" * 50)
print(Table de vérité d'un comparateur 1 bit (EXEMPLE Démo))
print("=" * 50)
print()
print("┌───┬───┬────────┬────────┬────────┐")
print("│ A │ B │ A > B  │ A = B  │ A < B  │")
print("├───┼───┼────────┼────────┼────────┤")
for a in [0, 1]:
    for b in [0, 1]:
        gt, eq, lt = one_bit_comparator(a, b)
        print(f"│ {a} │ {b} │ {gt} │ {eq} │ {lt} │")
print("└───┴───┴────────┴────────┴────────┘")

# Tester quelques scénarios utiles
print("\nScénario de test : ")
a_test, b_test = 1, 0
gt, eq, lt = one_bit_comparator(a_test, b_test)
print(f"A={a_test}, B={b_test}: A>B={gt}, A=B={eq}, A<B={lt}")
print(f"Interprétation : A est supérieur à B" if gt else ("A est égal à B" if eq else "A est inférieur à B"))

Cas 4 : décodeur 2 vers 4

ExigencesEntrez un nombre binaire de 2 bits (00, 01, 10, 11), et faites en sorte qu'exactement une des 4 lignes de sortie correspondantes soit égale à 1, les autres étant égales à 0.

Le décodeur est un composant essentiel du CPU — lorsque le CPU veut sélectionner un registre, il utilise essentiellement un décodeur.

Table de vérité

A1A0Y0Y1Y2Y3
001000
010100
100010
110001

expression logique

  • Y0 = NON(A1) ET NON(A0)
  • Y1 = NON(A1) ET A0
  • Y2 = A1 ET NON(A0)
  • Y3 = A1 ET A0

Exemple

# Décodeur 2-4 (exemple de démo)
# Entrée : nombre binaire de 2 bits A1 A0
# Sortie : exactement une des 4 lignes vaut 1

def AND(a, b):
    return 1 if a == 1 and b == 1 else 0

def NOT(a):
    return 1 if a == 0 else 0


def decoder_2to4(a1, a0):
    """
Décodeur de ligne 2 vers 4.
Renvoie la liste [Y0, Y1, Y2, Y3],
Exactement l’un d’entre eux vaut 1, les autres valent 0.
    """

    Y0 = AND(NOT(a1), NOT(a0))  # 00 → Y0
    Y1 = AND(NOT(a1), a0)       # 01 → Y1
    Y2 = AND(a1, NOT(a0))       # 10 → Y2
    Y3 = ET(a1, a0)            # 11 → Y3
    return [Y0, Y1, Y2, Y3]


# Afficher la table de vérité
print("=" * 50)
print(Table de vérité du décodeur 2-4 (Démo EXEMPLE))
print("=" * 50)
print()
print("┌────┬────┬────┬────┬────┬────┐")
print("│ A1 │ A0 │ Y0 │ Y1 │ Y2 │ Y3 │")
print("├────┼────┼────┼────┼────┼────┤")
for a1 in [0, 1]:
    for a0 in [0, 1]:
        Y = decoder_2to4(a1, a0)
        print(f"│ {a1}  │ {a0}  │ {Y[0]}  │ {Y[1]}  │ {Y[2]}  │ {Y[3]}  │")
print("└────┴────┴────┴────┴────┴────┘")

# Montrer un scénario d'utilisation réel
print("\nScénario d'application pratique : utiliser un décodeur pour sélectionner des registres)
registers = ["R0", "R1", "R2", "R3"]
for a1 in [0, 1]:
    for a0 in [0, 1]:
        Y = decoder_2to4(a1, a0)
        idx = Y.index(1)          # Trouver quelle ligne de sortie vaut 1
        print(fAdresse A1A0={a1}{a0} → sélectionne le registre {registers[idx]})

Le décodeur est un circuit classique « un vers plusieurs ». Son homologue est le multiplexeur (MUX), qui est « plusieurs vers un ». Les deux sont très courants dans la conception des chemins de données d'un CPU. Le décodeur sert à « sélectionner une cible » (par exemple, le registre dans lequel écrire), tandis que le multiplexeur sert à « sélectionner une source » (par exemple, le registre depuis lequel l'ALU lit les données).


Portes universelles : qu'est-ce qui rend NAND et NOR spéciales ?

Dans la fabrication réelle des puces, les portes NAND et NOR sont plus « bas niveau » que les portes AND et OR.

Porte NAND = AND + NOTAutrement dit, effectuez d'abord AND, puis inversez. NAND et NOR sont appelées « portes universelles » parce que chacune d'elles peut à elle seule implémenter toutes les fonctions booléennes.

Pourquoi les puces privilégient-elles NAND/NOR ? Parce qu'en technologie CMOS :

  • Une porte NAND ne nécessite que 4 transistors, alors qu'une porte AND en nécessite 6 (AND = NAND + NOT).
  • Les portes NAND ont une vitesse de commutation plus rapide
  • Par conséquent, la fonction AND dans les puces réelles est implémentée au niveau bas à l'aide de NAND + NOT.

Ensuite, vérifions l'« universalité » de la porte NAND :

Exemple

# Prouver l'« universalité » de la porte NAND (démo d'exemple)
# La porte NAND à elle seule peut implémenter les trois fonctions de base : NOT, AND, OR

def NAND(a, b):
    """Porte NAND : le résultat de AND est inversé.
Y = 0 si et seulement si a=1 et b=1"""

    return 0 if a == 1 and b == 1 else 1


Implémenter NOT à l'aide de NAND: NOT(A) = NAND(A, A)
def NOT_from_NAND(a):
    return NAND(a, a)


# utiliser l'implémentation NAND pour AND:AND(A,B) = NOT(NAND(A,B)) = NAND(NAND(A,B), NAND(A,B))
def AND_from_NAND(a, b):
    nand_ab = NAND(a, b)
    return NAND(nand_ab, nand_ab)


# Implémenter OR à l'aide de NAND: OR(A,B) = NAND(NOT(A), NOT(B))
def OR_from_NAND(a, b):
    return NAND(NOT_from_NAND(a), NOT_from_NAND(b))


# ============================================
# Vérifier
# ============================================
print("=" * 60)
print(Démontrer l'universalité des portes NAND (EXEMPLE de démonstration).)
print("=" * 60)

print("\n[Vérification : NOT implémenté par NAND]")
for a in [0, 1]:
    expected = 1 if a == 0 else 0
    actual = NOT_from_NAND(a)
    print(f" A={a}: NOT_from_NAND = {actual}, attendu = {expected}, {'Réussi' if actual == expected else 'Échec'}")

print("\n[Vérification : AND implémenté par NAND]")
for a in [0, 1]:
    for b in [0, 1]:
        expected = 1 if a == 1 and b == 1 else 0
        actual = AND_from_NAND(a, b)
        print(f" A={a}, B={b}: AND_from_NAND = {actual}, attendu = {expected}, {'Réussi' if actual == expected else 'Échec'}")

print("\n[Vérification : OR implémenté avec NAND])
for a in [0, 1]:
    for b in [0, 1]:
        expected = 1 if a == 1 or b == 1 else 0
        actual = OR_from_NAND(a, b)
        print(f" A={a}, B={b} : OR_from_NAND = {actual}, période attendue = {expected}, {'Réussi' if actual == expected else 'échec'}")

print("\nConclusion : seules les portes NAND sont nécessaires pour construire N'IMPORTE QUELLE fonction booléenne.)
print(C'est pourquoi le cours nand2tetris peut construire un ordinateur entier à partir de portes NAND.)

nand2tetris (From NAND to Tetris) est un célèbre cours d'informatique. Il vous met au défi de construire un CPU, de la mémoire et un système d'exploitation étape par étape en n'utilisant que des portes NAND, puis enfin d'exécuter un jeu Tetris. Si vous êtes intéressé par les détails de bas niveau des ordinateurs, je le recommande vivement.


Démo interactive : constructeur de circuit de vote majoritaire (exemple de démo vis-network)

Utilisez ci-dessousvis-networkIl visualise un circuit de vote majoritaire à trois entrées (Y = AB + BC + AC).Cliquez sur les nœuds d'entrée A, B, C pour basculer entre 0/1, le circuit évaluera et mettra automatiquement à jour les couleurs de tous les fils —Rougeindique que le signal est 1,grisindique que le signal est 0.

Vote majoritaire à trois entrées (cliquez sur les nœuds A/B/C pour basculer)

A=0, B=0, C=0 → Non validé (nécessite au moins 2 votes en faveur)
Nœud d'entrée A Nœud d'entrée B Nœud d'entrée C Porte AND Porte OR Sortie Y
autres extensions