« Fonctionnement d'un ordinateur/Les circuits combinatoires » : différence entre les versions

Contenu supprimé Contenu ajouté
mAucun résumé des modifications
Ligne 7 :
Dans ce qui va suivre, nous allons voir comment concevoir ce genre de circuits. Il existe des méthodes et procédures assez simples qui permettent à n'importe qui de créer n'importe quel circuit combinatoire. Nous allons voir comment créer des circuits combinatoires à plusieurs entrées, mais à une seule sortie. Pour simplifier, on peut considérer que les bits envoyés en entrée sont un nombre, et que le circuit calcule un bit à partir du nombre envoyé en entrée.
 
[[File:Exemple d'un circuit électronique à une seule sortie.jpg|centre|vignette|upright=2|Exemple d'un circuit électronique à une seule sortie.]]
 
C'est à partir de circuits de ce genre que l'on peut créer des circuits à plusieurs sorties : il suffit d'assembler plusieurs circuits à une sortie. La méthode pour ce faire est très simple : chaque sortie est calculée indépendamment des autres, uniquement à partir des entrées. Ainsi, pour chaque sortie du circuit, on crée un circuit à plusieurs entrées et une sortie : ce circuit déduit quoi mettre sur cette sortie à partir des entrées. En assemblant ces circuits à plusieurs entrées et une sortie, on peut ainsi calculer toutes les sorties.
 
[[File:Comment créer un circuit à plusieurs sorties avec des sous-circuits à une sortie.jpg|centre|vignette|upright=2|Comment créer un circuit à plusieurs sorties avec des sous-circuits à une sortie.]]
 
==Décrire un circuit : tables de vérité et équations logiques==
Ligne 26 :
 
Le premier exemple sera très simple. Le circuit que l'on va créer sera un inverseur commandable, qui fonctionnera soit comme une porte NON, soit se contentera de recopier le bit fournit en entrée. Pour faire le choix du mode de fonctionnement (inverseur ou non), un bit de commande dira s'il faut que le circuit inverse ou non l'autre bit d'entrée :
 
* quand le bit de commande vaut zéro, l'autre bit est recopié sur la sortie ;
* quand il vaut 1, le bit de sortie est égal à l'inverse du bit d'entrée (pas le bit de commande, l'autre).
Ligne 75 ⟶ 74 :
 
Pour le dernier exemple, nous allons prendre en entrée un nombre de 3 bits. Le but du circuit à concevoir sera de déterminer le bit majoritaire dans ce nombre : celui-ci contient-il plus de 1 ou de 0 ? Par exemple :
 
* le nombre 010 contient deux 0 et un seul 1 : le bit majoritaire est 0 ;
* le nombre 011 contient deux 1 et un seul 0 : le bit majoritaire est 1 ;
Ligne 129 ⟶ 127 :
 
Les équations obtenues ont une forme similaire aux exemples qui vont suivre. Ces exemples sont donnés pour un circuit à trois entrées nommées a, b et c, et une sortie s. On voit que certaines entrées sont inversées avec une porte NON, et que le résultat de l'inversion est ensuite combiné avec des portes ET et OU.
 
* Exemple de forme normale conjonctive : <math>( a + b + c ) . ( \overline{a} + b + c ) . ( \overline{a} + \overline{b} + c ) . ( a + b + \overline{c}) . ( \overline{a} + \overline{b} + \overline{c} )</math>.
* Exemple de forme normale disjonctive : <math>( a . b . c ) + ( \overline{a} . b . c ) + ( \overline{a} . \overline{b} . c ) + ( a . b . \overline{c}) + ( \overline{a} . \overline{b} . \overline{c} )</math>.
Ligne 166 ⟶ 163 :
Tout circuit de ce type est systématiquement composé de deux couches de portes logiques : une couche de portes NON et une porte ET à plusieurs entrées. Créer un tel circuit se fait en trois étapes. En premier lieu, il faut convertir la constante à vérifier en binaire : dans ce qui suit, nous nommerons cette constante k. En second lieu, il faut créer la couche de portes NON. Pour cela, rien de plus simple : on place des portes NON pour les entrées de la constante k qui sont à 0, et on ne met rien pour les bits à 1. Par la suite, on place une porte ET à plusieurs entrées à la suite de la couche de portes NON.
 
[[File:Exemples de comparateurs (la constante est indiquée au-dessus du circuit).jpg|centre|vignette|upright=2|Exemples de comparateurs (la constante est indiquée au-dessus du circuit).]]
 
Pour comprendre pourquoi on procède ainsi, il faut simplement regarder ce que l'on trouve en sortie de la couche de portes NON :
 
* si on envoie la constante, tous les bits à 0 seront inversés alors que les autres resteront à 1 : on se retrouve avec un nombre dont tous les bits sont à 1 ;
* si on envoie un autre nombre, soit certains 0 du nombre en entrée ne seront pas inversés, ou alors des bits à 1 le seront : il y aura au moins un bit à 0 en sortie de la couche de portes NON.
Ligne 175 ⟶ 171 :
Ainsi, on sait que le nombre envoyé en entrée est égal à la constante k si et seulement si tous les bits sont à 1 en sortie de la couche de portes NON. Dit autrement, la sortie du circuit doit être à 1 si et seulement si tous les bits en sortie des portes NON sont à 1 : il ne reste plus qu'à trouver un circuit qui prenne ces bits en entrée et ne mette sa sortie à 1 que si tous les bits d'entrée sont à 1. Il existe une porte logique qui fonctionne ainsi : il s'agit de la porte ET à plusieurs entrées.
 
[[File:Fonctionnement d'un comparateur avec une constante.jpg|centre|vignette|upright=2|Fonctionnement d'un comparateur avec une constante.]]
 
====Combiner les comparateurs avec une constante====
 
On peut créer n'importe quel circuit à une seule sortie avec ces comparateurs, en les couplant avec une porte OU à plusieurs entrées. Pour comprendre pourquoi, rappelons que les entrées du circuits peuvent prendre plusieurs valeurs : pour une entrée de <math>n</math> bits, on peut placer <math>2^n</math> valeurs différentes sur l'entrée. Mais seules certaines valeurs doivent mettre la sortie à 1, les autres la laissant à 0. Les valeurs d'entrée qui mettent la sortie 1 sont aussi appelées des '''minterms'''. Ainsi, pour savoir si il faut mettre un 1 en sortie, il suffit de vérifier que l'entrée est égale à un minterm. Pour savoir si l'entrée est égale à un minterm, on doit utiliser un comparateur avec une constante pour chaque minterm. Par exemple, pour un circuit dont la sortie est à 1 si son entrée vaut 0000, 0010, 0111 ou 1111, il suffit d'utiliser :
 
* un comparateur qui vérifie si l'entrée vaut 0000 ;
* un comparateur qui vérifie si l'entrée vaut 0010 ;
Ligne 188 ⟶ 183 :
Reste à combiner les sorties de ces comparateurs pour obtenir une seule sortie, ce qui est fait en utilisant un circuit relativement simple. On peut remarquer que la sortie du circuit est à 1 si un seul comparateur a sa sortie à 1. Or, on connait un circuit qui fonctionne comme cela : la porte OU à plusieurs entrées. En clair, on peut créer tout circuit avec seulement des comparateurs et une porte OU à plusieurs entrées.
 
[[File:Conception d'un circuit à partir de minterms.jpg|centre|vignette|upright=2.5|Conception d'un circuit à partir de minterms]]
 
===Méthode des minterms, version formalisée===
Ligne 231 ⟶ 226 :
 
Les deux étapes précédentes sont les seules réellement nécessaires : quelqu'un qui sait créer un comparateur avec une constante (ce qu'on a vu plus haut), devrait pouvoir s'en sortir. Reste à savoir comment transformer une table de vérité en équations logiques, et enfin en circuit. Pour cela, il n'y a pas trente-six solutions : on va écrire une équation logique qui permettra de calculer la valeur (0 ou 1) d'une sortie en fonction de toutes les entrées du circuit. Et on fera cela pour toutes les sorties du circuit que l'on veut concevoir. Pour ce faire, on peut utiliser ce qu'on appelle la méthode des minterms, qui est strictement équivalente à la méthode vue au-dessus. Elle permet de créer un circuit en quelques étapes simples :
 
* lister les lignes de la table de vérité pour lesquelles la sortie vaut 1 (comme avant) ;
* écrire l'équation logique pour chacune de ces lignes (qui est celle d'un comparateur) ;
Ligne 237 ⟶ 231 :
 
Pour écrire l'équation logique d'une ligne, il faut simplement :
 
* lister toutes les entrées de la ligne ;
* faire un NON sur chaque entrée à 0 ;
Ligne 261 ⟶ 254 :
 
On a alors :
 
* la première ligne où l'entrée vaut 001 : son équation logique vaut <math>\overline{e2}.\overline{e1}.e0</math> ;
* la seconde ligne où l'entrée vaut 010 : son équation logique vaut <math>\overline{e2}.e1.e0</math> ;
Ligne 286 ⟶ 278 :
 
Seconde étape, écrire les équations de chaque ligne. Essayez par vous-même, avant de voir la solution ci-dessous.
 
* Pour la première ligne, l'équation obtenue est : <math>\overline{e2}.e1.e0</math>.
* Pour la seconde ligne, l'équation obtenue est : <math>e2.\overline{e1}.e0</math>.
Ligne 400 ⟶ 391 :
 
Vient ensuite la traduction de chaque ligne en équation logique. Cette fois-ci, les bits à 1 dans l'entrée sont ceux qui doivent être inversés, les autres restants tels quels. De plus, on doit faire un OU entre ces bits. On a donc :
 
* <math>a + b + c</math> pour la première ligne ;
* <math>a + \overline{b} + c</math> pour la seconde ligne ;
Ligne 423 ⟶ 413 :
* La seconde étape combine les résultats de tous les maxterms pour déduire la sortie. Si tous les comparateurs renvoient un 1, cela signifie que l'entrée est différente de tous les maxterms : ce n'en est pas un. La sortie doit alors être mise à 1. Si l'entrée correspond à un maxterm, alors le comparateur associé au maxterm donnera un 0 en sortie : il y aura au moins un comparateur qui donnera un 0. Dans ce cas, la sortie doit être mise à 0. On remarque rapidement que ce comportement est celui d'une porte ET à plusieurs entrées.
 
[[File:Conception d'un circuit à partir de maxterms.jpg|centre|vignette|upright=2.5|Conception d'un circuit à partir de maxterms.]]
 
====Le circuit de comparaison====
Ligne 542 ⟶ 532 :
 
Comme premier exemple, nous allons travailler sur cette équation : <math>(\overline{e2}.e1.e0)+(e2.e1.e0)</math>. On peut la simplifier en trois étapes :
 
* Appliquer la règle de distributivité du ET sur le OU pour factoriser le facteur e1.e0, ce qui donne <math>(e2+\overline{e2}).e1.e0</math> ;
* Appliquer la règle de complémentarité sur le terme entre parenthèses <math>(e2+\overline{e2})</math>, ce qui donne 1.e1.e0 ;
;
* Et enfin, utiliser la règle de l’élément neutre du ET, qui nous dit que a.1=a, ce qui donne : e1.e0.
 
En guise de second exemple, nous allons simplifier <math>(\overline{e2}.e1.e0)+(e2.\overline{e1}.e0)</math>. Cela se fait en suivant les étapes suivantes :
 
* Factoriser e0, ce qui donne : <math>(e0 . \overline{e2}.e1)+(e2.\overline{e1})</math>;
* Utiliser la règle du XOR qui dit que <math>a \oplus b = b \oplus a</math>, ce qui donne <math>(e2 \oplus e1).e0</math>.
Ligne 585 ⟶ 572 :
 
Trouver l'équation qui correspond à un regroupement est un processus en plusieurs étapes, que nous illustrerons dans ce qui va suivre. Ce processus demande de :
 
* trouver la variable qui ne varie pas dans les lignes et colonnes attribuées au regroupement ;
* inverser la variable si celle-ci vaut toujours zéro dans le regroupement ;
Ligne 608 ⟶ 594 :
!Sortie
|-
|0||0||0||0
|0
|0
|0
|0
|-
|0||0||1||0
|0
|0
|1
|0
|-
|0||1||0||1
|0
|1
|0
|1
|-
|0||1||1||1
|0
|1
|1
|1
|-
|1||0||0||0
|1
|0
|0
|0
|-
|1||0||1||1
|1
|0
|1
|1
|-
|1||1||0||0
|1
|1
|0
|0
|-
|1||1||1||1
|1
|1
|1
|1
|}
 
Ligne 658 ⟶ 620 :
!Sortie
|-
|0||1||0||1
|0
|1
|0
|1
|-
|0||1||1||1
|0
|1
|1
|1
|-
|1||0||1||1
|1
|0
|1
|1
|-
|1||1||1||1
|1
|1
|1
|1
|}
 
Ligne 705 ⟶ 655 :
Le circuit qui correspond est :
 
[[Fichier:Multiplexeur_à_deux_entrées_-_circuit.png|centre|vignette|upright=2|Multiplexeur à deux entrées - circuit]]
 
<noinclude>