Dans les exemples précédents, nous avons manipulé des variables booléennes simples et nous les avons représentées sous la forme de conducteurs séparés dans des circuits logiques. Cependant, lorsqu’une fonction logique traite des nombres représentés en binaire, il est plus pratique de regrouper les bits d’un même nombre sous la forme d’un vecteur auquel on donnera un nom et dont chaque élément sera identifié par un indice. Par exemple, un nombre compris entre 0 et 255 pourra être représenté par un vecteur de huit bits où l’indice le plus grand correspond au bit de poids fort et l’indice le plus petit correspond au bit de poids faible.
Ainsi, il est possible de représenter des fonctions logiques de manière plus concise. Sur le schéma ci-dessous, le même circuit est dessiné de deux manières différentes : à gauche, le symbole de la porte ET est relié à des vecteurs de quatre bits , et ; à droite, nous détaillons la structure de ce circuit sous la forme de quatre portes ET. Les conducteurs qui transportent un bit sont représentés par des traits fins tandis que les vecteurs sont représentés par des traits épais avec une indication du nombre de bits.
Dans l’exemple précédent, un symbole relié à des vecteurs représente le regroupement de plusieurs circuits logiques identiques. Mais ce n’est pas toujours le cas. Sur le schéma suivant, le symbole représente un additionneur capable de calculer la somme de deux nombres sur quatre bits. On ne peut pas simplement détailler ce circuit en quatre additionneurs indépendants.
Un décodeur est un circuit qui possède entrées et sorties. À chaque combinaison possible de valeurs en entrée, correspond une, et une seule sortie.
La table de vérité suivante donne l’exemple d’un décodeur à trois entrées. Chacune des huit combinaisons possibles de active l’une des huit sorties. Ici, nous avons suivi l’ordre de la numération binaire, c’est-à-dire que les combinaisons d’entrées représentent les nombres compris entre 0 et 7. La valeur de indique le numéro de la sortie à activer.
→ | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
0 | 0 | 0 | → | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
0 | 0 | 1 | → | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
0 | 1 | 0 | → | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
0 | 1 | 1 | → | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
1 | 0 | 0 | → | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 |
1 | 0 | 1 | → | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
1 | 1 | 0 | → | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
1 | 1 | 1 | → | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Nous allons proposer une nouvelle version de la partie commande de notre robot. Nous choisissons d’utiliser un décodeur afin de reconnaître les différentes combinaisons possibles des boutons-poussoirs. Chaque action de déplacement sera ainsi associée à une sortie du décodeur.
Ci-dessous, nous avons repris la table de vérité de la partie commande du robot en ne conservant que les lignes où au moins une sortie vaut 1 et en ajoutant une indication de la sortie du décodeur active pour chaque ligne.
BA | BR | BG | BD | → | Sortie du décodeur | → | MGA | MGR | MDA | MDR |
---|---|---|---|---|---|---|---|---|---|---|
1 | 0 | 0 | 0 | → | → | 1 | 0 | 1 | 0 | |
0 | 1 | 0 | 0 | → | → | 0 | 1 | 0 | 1 | |
0 | 0 | 1 | 0 | → | → | 0 | 1 | 1 | 0 | |
0 | 0 | 0 | 1 | → | → | 1 | 0 | 0 | 1 | |
1 | 0 | 1 | 0 | → | → | 0 | 0 | 1 | 0 | |
1 | 0 | 0 | 1 | → | → | 1 | 0 | 0 | 0 | |
0 | 1 | 1 | 0 | → | → | 0 | 0 | 0 | 1 | |
0 | 1 | 0 | 1 | → | → | 0 | 1 | 0 | 0 |
On peut donc écrire les équations des sorties de la manière suivante :
Sur le schéma ci-dessous, nous observons que le décodeur est simplement venu remplacer les inverseurs et les portes ET de notre schéma précédent non optimisé.
Un multiplexeur est un circuit d’aiguillage qui permet de sélectionner une entrée de donnée parmi voies en fonction d’une entrée de sélection sur bits. L’entrée de sélection est également appelée adresse. La figure ci-dessous représente trois multiplexeurs avec respectivement un bit d’adresse (deux voies de données), deux bits d’adresse (quatre voies de données) et trois bits d’adresse (huit voies de données).
L’entrée d’adresse indique le numéro de l’entrée de données à sélectionner. La valeur de cette entrée est alors copiée sur la sortie . Par exemple, pour un multiplexeur à un bit d’adresse, nous avons :
La table de vérité d’un multiplexeur est typiquement présentée sous une forme réduite, c’est-à-dire qu’on ne cherche pas à énumérer toutes les combinaisons possibles d’entrées mais on peut faire figurer des expressions booléennes simples dans les colonnes de sortie.
→ | ||
---|---|---|
0 | → | |
1 | → |
Cette forme est équivalente à la table de vérité suivante avec cas indifférents :
→ | ||||
---|---|---|---|---|
0 | – | 0 | → | 0 |
0 | – | 1 | → | 1 |
1 | 0 | – | → | 0 |
1 | 1 | – | → | 1 |
Le multiplexeur permet de construire rapidement un circuit à partir d’une table de vérité. Par exemple, si nous souhaitons réaliser la partie commande de notre robot, nous pouvons utiliser des multiplexeurs à seize voies, en associant à chaque combinaison de l’état des boutons les valeurs attendues en sortie.
La table de vérité d’un multiplexeur à quatre bits d’adresse est résumée ci-dessous.
→ | |||||
---|---|---|---|---|---|
0 | 0 | 0 | 0 | → | |
0 | 0 | 0 | 1 | → | |
0 | 0 | 1 | 0 | → | |
0 | 0 | 1 | 1 | → | |
⋮ | ⋮ | ⋮ | ⋮ | ⋮ | ⋮ |
1 | 1 | 1 | 0 | → | |
1 | 1 | 1 | 1 | → |
Si nous décidons, par exemple, que , , , et , il suffit d’affecter à chaque voie la valeur de correspondant à la combinaison d’états des boutons. Le circuit complet est représenté ci-dessous.
L’additionneur peut être considéré comme un des circuits de base dans de nombreuses applications. Nous aurons l’occasion de l’utiliser à nouveau lorsque nous présenterons les circuits compteurs.
La figure ci-dessous représente un symbole possible pour un circuit additionneur sur quatre bits. Les nombres à additionner sont présentés en binaire sur les entrées et . La somme est disponible sur la sortie tandis que la sortie indique si l’addition des bits de poids fort a engendré une retenue.
Nous ne détaillerons pas la structure interne de ce circuit.
La sortie peut être reliée à l’entrée d’un autre additionneur afin d’additionner des nombres sur un plus grand nombre de bits. Dans l’exemple ci-dessous, nous avons réalisé un additionneur sur 12 bits en utilisant trois additionneurs sur 4 bits.
Le premier additionneur calcule la somme des quatre bits de poids faible de et ainsi qu’une retenue. Le deuxième additionneur calcule la somme des bits 7 à 4 de et , en ajoutant la retenue éventuellement produite par l’additionneur précédent. Le troisième additionneur calcule la somme des quatre bits de poids fort de et , en ajoutant la retenue éventuellement produite par l’additionneur précédent.
Suivant le même principe, on trouvera des circuits soustracteurs, des multiplieurs, des unités arithmétiques et logiques (UAL) capables d’effectuer différentes opérations.
Un comparateur est un circuit qui compare deux nombres et représentés en binaire et qui fournit des indications sur les relations entre ces deux nombres. Typiquement, un comparateur possédera des sorties booléennes correspondant à différentes conditions que l’on souhaite vérifier sur et (, , ).
L’exemple ci-dessous illustre l’utilisation d’un comparateur et de multiplexeurs pour calculer le maximum et le minimum de deux nombres. Le circuit réalise cet algorithme :
si x < y alors
min ← x
max ← y
sinon
min ← y
max ← x
fin si
Un décodeur est un circuit logique avec bits en entrée et bits en sorties. Chaque combinaison d’entrées active une, et une seule sortie.
Un multiplexeur est un circuit logique avec bits d’adresse et bits de données en entrée. La sortie reçoit la valeur de l’entrée de données correspondant à l’adresse courante.
Les décodeurs et multiplexeurs fournissent un moyen rapide pour réaliser des fonctions logiques dont on connaît la table de vérité.
Il est possible de construire et de réutiliser des circuits logiques pour effectuer des calculs et des comparaisons entre des nombres entiers représentés en binaire.