Il est possible de simuler l'essentiel des montages de logique combinatoire avec le logiciel libre Logisim.
Dans un système combinatoire, chaque sortie Sk de k=0 à k=m-1 est une expression booléenne des entrées ej de j=0 à j=n-1.
Les expressions booléennes peuvent être simplififiées, ce qui fait que certaines variables d'entrée peuvent ne pas apparaître dans l'expression booléenne des sorties.
A chaque combinaison des variables d'entrées correspond une valeur et une seule pour chaque sortie.
Le nombre de combinaison des entrées est égale à 2n
Le nombre de sorties est défini par la fonction combinatoire à réaliser.
Mon conseil :
Avant de lire la suite, il est vivement recommandé, si cela n'est déjà fait, de lire le chapitre concernant la représentation et l'addition des entiers signés et non signés en binaire.
Le codeur ou encodeur est un système combinatoire qui possède de n entrées et m sorties qui respectent la relation n=2m.
e0 | e1 | e2 | e3 | e4 | e5 | e6 | e7 | S2 | S1 | S0 |
---|---|---|---|---|---|---|---|---|---|---|
1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 |
0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 |
0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 |
0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 0 |
0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |
Si on affecte un poids binaire aux sorties par rapport à l'indice, alors la valeur binaire des sorties correspond au numéro de l'indice de l'entrée activée.
On peut remarquer que la table de vérité est imcomplète car elle ne représente que les combinaisons des entrées utilisées. Pour les expressions booléennes des sorties, on peut soit écrire l'expression en fonction de toutes les sorties et faire en sorte que toute autre combinaison que celle de la table donne 0, ou encore simplifier les expressions booléennes, ce qui fait que les combinaisons des entrées non prévues donneront un résultat inattendu.
Un codeur prioritaire fournit une valeur en fonction de la valeur maximale de l'entrée activée.
e0 | e1 | e2 | e3 | e4 | e5 | e6 | e7 | S2 | S1 | S0 |
---|---|---|---|---|---|---|---|---|---|---|
1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
X | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
X | X | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
X | X | X | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 |
X | X | X | X | 1 | 0 | 0 | 0 | 1 | 0 | 0 |
X | X | X | X | X | 1 | 0 | 0 | 1 | 0 | 1 |
X | X | X | X | X | X | 1 | 0 | 1 | 1 | 0 |
X | X | X | X | X | X | X | 1 | 1 | 1 | 1 |
Dans ce cas toutes les combinaisons des entrées sont définies. Le code en sortie correspond à l'entrée de plus grand indice qui est activée.
Exemple :
si les entrées e1 et e2 sont activées le code en entrée est 01100000, code qui correspond au code de sortie 010 (210),
ce code indique que l'entrée de plus haut niveau activée est 2.
Si l'on affecte un poids binaire aux entrées par rapport aux indices, l'exemple précédent montre que l'image de la valeur 6 est 2
Plus généralement, la fonction mathématique réalisée par ce circuit est :
e0 | e1 | e2 | e3 | e4 | e5 | e6 | e7 | S2 | S1 | S0 |
---|---|---|---|---|---|---|---|---|---|---|
0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | x | x | x |
1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 |
0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 |
0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 0 |
0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 |
0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | 1 |
0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 |
0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 0 |
0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 0 |
0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 |
0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |
Le décodeur est un système combinatoire qui possède de n entrées et m sorties qui respectent la relation m=2n.
e2 | e1 | e0 | S0 | S1 | S2 | S3 | S4 | S5 | S6 | S7 |
---|---|---|---|---|---|---|---|---|---|---|
0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 |
1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
Ici on a 3 entrées et 8 combinaisons, toutes les combinsaisons sont donc définies.
Comme pour le codeur, si on affecte un poids binaire aux entrées pour obtenir une valeur décimale, le numéro de la sortie activée correspond à la valeur décimale des entrées.
Exemple
avec la combinaison d'entrée e2=1, e1=0 et e0=0 qui donne 01002=410, c'est la sortie d'indice 4 qui est activée.
Si on affecte également une valeur décimale à la sortie en utilisant les indices comme références des poids binaires, avec la valeur 4 en entrée, on obtient 24=16 en sortie.
Plus généralement, la fonction mathématique réalisée par cette fonction est : S=2E avec S qui représente la valeur décimale équivalente des sorties de poids binaire de 0 à 7, et E qui représente la valeur décimale équivalente des entrées de poids binaire de 0 à 2.
e2 | e1 | e0 | S0 | S1 | S2 | S3 | S4 | S5 | S6 | S7 |
---|---|---|---|---|---|---|---|---|---|---|
0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 |
1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
Le multiplexeur est un système combinatoire qui possède de m entrées d'adresses, n=2m lignes d'entrées et une sortie. La valeur binaire de l'adresse permet de connecter l'entrée correspondante à la valeur décimale de l'adresse à la sortie.
a2 | a1 | a0 | S |
---|---|---|---|
0 | 0 | 0 | e0 |
0 | 0 | 1 | e1 |
0 | 1 | 0 | e2 |
0 | 1 | 1 | e3 |
1 | 0 | 0 | e4 |
1 | 0 | 1 | e5 |
1 | 1 | 0 | e6 |
1 | 1 | 1 | e7 |
La table de vérité complète comporte 11 entrées et 1 sortie, ce qui donne 2048 combinaisons. La table de vérité proposée est simplififiée en donnant l'entrée qui est connectée à la sortie en fonction des valeurs binaires des adresses.
Si on prend la valeur de l'adresse a2=1, a1=0, a0=0 qui donne A=1002=410, on peut lire que la sortie S est reliée à l'entrée e4. Ce qui signifie que si e4=0 alors S=0 et si e4=1 alors S=1.
Le démultiplexeur est un système combinatoire qui possède de m entrées d'adresses, 1 ligne d'entrée, n=2m sorties. La valeur binaire de l'adresse permet de connecter l'entrée à la sortie correspondante à la valeur décimale de l'adresse.
a2 | a1 | a0 | S0 | S1 | S2 | S3 | S4 | S5 | S6 | S7 |
---|---|---|---|---|---|---|---|---|---|---|
0 | 0 | 0 | e | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 0 | 1 | 0 | e | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 0 | 0 | e | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 1 | 0 | 0 | 0 | e | 0 | 0 | 0 | 0 |
1 | 0 | 0 | 0 | 0 | 0 | 0 | e | 0 | 0 | 0 |
1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | e | 0 | 0 |
1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | e | 0 |
1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | e |
La table de vérite comporte 4 entrée et 8 sorties. On aurait pu la représenter complètement, mais on préfère utiliser la même représentation que pour le multiplexeur.
Si on prend la valeur de l'adresse a2=1, a1=0, a0=0 qui donne A=1002=410, on peut lire que la sortie S4 est reliée à l'entrée e. Ce qui signifie que si e=0 alors S4=0 et si e=1 alors S4=1, les autres sorties étant toutes à 0 quelue soit la valeur de l'entrée e.
C'est un système qui permet de comparer deux valeurs exprimées en binaire et de fournir des booléens qui indiquent si a=b, a<b ou encore a>b.
La sortue Eg est vraie si a=b, la sortie Sup est vraie si a>b et la sortie Inf est vraie si a<b.
a | b | Eg | Sup | Inf |
---|---|---|---|---|
0 | 0 | 1 | 0 | 0 |
0 | 1 | 0 | 0 | 1 |
1 | 0 | 0 | 1 | 0 |
1 | 1 | 1 | 0 | 0 |
Cela donne les équations :
On ne va pas donner la table de vérité avec 5 entrées et 3 sorties.
Les règles de la mise en cascade sont les suivantes :
Cela donne les équations :
On utilise les comparateurs 1 bit cascadables, en commmençant par comparer les bits de poids fort pour terminer par les bits de poids faible. Il ne faut pas oublier les entrées du premier comparateur de façon à ce que la comparaison des bits de poids fort soit effective.
Exemple avec la comparaison de deux mots de 4 bits (n=4) non signés.
a3 | a2 | a1 | a0 | b3 | b2 | b1 | b0 | Résultat |
---|---|---|---|---|---|---|---|---|
1 | X | X | X | 0 | X | X | X | a>b |
0 | 1 | X | X | 0 | 0 | X | X | a>b |
0 | 0 | 1 | X | 0 | 0 | 0 | X | a>b |
A | A | B | B | Eg | Inf | Sup |
---|---|---|---|---|---|---|
0 | 0000 | 0 | 0000 | 1 | 0 | 0 |
8 | 1000 | 0 | 0000 | 0 | 0 | 1 |
8 | 1000 | 4 | 0100 | 0 | 0 | 1 |
8 | 1000 | 5 | 0101 | 0 | 0 | 1 |
8 | 1000 | 7 | 0111 | 0 | 0 | 1 |
8 | 1000 | 3 | 0011 | 0 | 0 | 1 |
0 | 0000 | 3 | 0011 | 0 | 1 | 0 |
4 | 0100 | 3 | 0011 | 0 | 0 | 1 |
12 | 1100 | 3 | 0011 | 0 | 0 | 1 |
A | A | B | B | Eg | Inf | Sup |
---|---|---|---|---|---|---|
0 | 0000 | 0 | 0000 | 1 | 0 | 0 |
-8 | 1000 | 0 | 0000 | 0 | 1 | 0 |
-8 | 1000 | 4 | 0100 | 0 | 1 | 0 |
-8 | 1000 | 5 | 0101 | 0 | 1 | 0 |
-8 | 1000 | 7 | 0111 | 0 | 1 | 0 |
-8 | 1000 | 3 | 0011 | 0 | 1 | 0 |
0 | 0000 | 3 | 0011 | 0 | 1 | 0 |
4 | 0100 | 3 | 0011 | 0 | 0 | 1 |
-4 | 1100 | 3 | 0011 | 0 | 1 | 0 |
L' additionneur 1 bit réalise l'addition de deux nombres exprimés sur 1 bit avec ou sans retenue d'entrée. On va étudier l'additionneur avec retenue d'entrée appelé additionneur complet (full-adder en Anglais).
Re | a | b | Rs | S |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 0 | 1 | 0 | 1 |
0 | 1 | 0 | 0 | 1 |
0 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 0 | 1 |
1 | 0 | 1 | 1 | 0 |
1 | 1 | 0 | 1 | 0 |
1 | 1 | 1 | 1 | 1 |
On utilise n additionneurs complets 1 bit en commençant par l'addtion du bit de poids faible. La retenue d'entrée de chaque additionneur de rang k est reliée à la retenue de sortie de rang k-1. Rek=Rsk-1 avec Re0=0.
L'inconvénient de la mise en cascade d'additionneur est la propagation de la retenue définit le temps de propagation de l'additionneur. Il existe de nombreuses méthodes d'optimisation de calcul de la retenue afin de minimiser le temps de propagation d'un additionneur comme l'additionneur à retenue anticipée.
Le schéma représente un additionneur 4 bits avec retenue d'entrée C0 et retenue de sortie C3.
Elle se fait en ajoutant le complément à deux de la deuxième opérande : A-B=A+B̅+1 avec + qui est l'opération d'addition.
En utilisant la relation ci-dessus, réaliser un soustracteur 4 bits à l'aide d'un additionneur 4 bits et de portes logiques
La valeur B devient B̅ à l'entrée de l'additionneur ce qui donne l'addition S=A+B̅.
Le positionnement de la retenue d'entrée C0 à 1 permet d'ajouter 1.
Finalement on obtient S=A+B̅+1 qui est bien la soustraction de A-B.
Entiers non signés | |||||||
---|---|---|---|---|---|---|---|
A | A | B | B | B̅ | A+B̅ | S | S |
8 | 1000 | 4 | 0100 | 1011 | 0011 | 0100 | 4 |
12 | 1100 | 7 | 0111 | 1000 | 0100 | 0101 | 5 |
Entiers signés | |||||||
---|---|---|---|---|---|---|---|
A | A | B | B | B̅ | A+B̅ | S | S |
3 | 0011 | -2 | 1110 | 0001 | 0100 | 0101 | 5 |
-4 | 1100 | 3 | 0011 | 1100 | 1000 | 1001 | -7 |
En utilisant la relation ci-dessus, réaliser un additionneur/soustracteur 4 bits à l'aide d'un additionneur 4 bits et de portes logiques. Le choix de l'opération se fait à l'aide d'un signal de commande as qui, lorsqu'il vaut 0 réalise une addition, et une soustraction lorsque'il vaut 1.
La porte OU exclusif est un invserseur commandé lorsque l'une des entrée est à 0, la sortie est égale à l'autre entrée, lorsqu'une entrée est à 1, la sortie est égale à l'inverse de l'autre entrée.
S=ab̅+a̅b
as | CI | S |
---|---|---|
0 | 0 | A+B |
1 | 1 | A+B̅+1=A-B |
l'UAL (ALU en Anglais) est un circuit combinatoire qui réalise les opérations logiques et arithmétiques en fonction d'un code d'entrée :
Ce circuit fournit le résultat de l’opération et positionne les bits spéciaux :
Le dépassement correspond à deux cas de fonctionnement :
La somme S de deux nombres positifs A et B donne un nombre négatif
Rsn-2 | |||
0 | ...... | a0 | |
0 | ...... | b0 | |
Rsn-1 | Sn-1 | ...... | S0 |
Le résultat est négatif si Sn-1=1 ce qui implique que Rsn-2=1 et Rsn-1=0.
On a donc un dépassement
La somme S de deux nombres négatifs A et B donne un nombre positif
Rsn-2 | |||
1 | ...... | a0 | |
1 | ...... | b0 | |
Rsn-1 | Sn-1 | ...... | S0 |
Le résultat est positif si Sn-1=0 ce qui implique que Rsn-2=0 et Rsn-1=1.
On a donc un dépassement
L'UAL n'a pas de sorties de comparaisons, pour comparer deux entiers A et B, on réalise la soustraction A-B, puis on déduit le résultat de la comparaison des bits ZNCO.
L'interprétation de ces bits n'est pas le même suivant que l'on compare des entiers signés ou non signés.
type entier | Equation | Comparaison |
---|---|---|
non signé | C=1 | A ≥ B |
non signé | C=0 | A < B |
signé | N ⊕ O=0 | A ≥ B |
signé | N ⊕ O=1 | A < B |
Soit à comparer les valeurs A=12 et B=7 exprimés sur 4 bits non signes
Eléments de solution
0 | 1 | 1 | 1 |
1 | 0 | 0 | 1 |
0 | 1 | 0 | 1 |
Z | = | 0 |
N | = | 0 |
C | = | 1 |
O | = | 1 |
Soit à comparer les valeurs A=2 et B=8 exprimés sur 4 bits non signes
Eléments de solution
1 | 0 | 0 | 0 |
1 | 0 | 0 | 0 |
1 | 0 | 1 | 0 |
Z | = | 0 |
N | = | 1 |
C | = | 0 |
O | = | 1 |
Soit à comparer les valeurs A=-5 et B=-4 exprimés sur 4 bits signes
Eléments de solution
1 | 1 | 0 | 0 |
0 | 1 | 0 | 0 |
1 | 1 | 1 | 1 |
Z | = | 0 |
N | = | 1 |
C | = | 0 |
O | = | 0 |
sur bits, puis demander une
Autrefois, l'implémentation des solutions logiques se faisait avec des circuits intégrés incluant uniquement des portes logiques et les fonctions combinatoires décrites précédement. La synthèse servait à élaborer les schémas des solutions logiques avec des portes logiques.
Le logigramme est, dans le cas pérsent, le schéma de la fonction logique simplifiée qui est réalisée avec des opérateurs et fonctions logiques. Généralement on utilise des opérateurs NON, des fonctions ET et des fonctions OU.
Les exemples suivants sont repris des exemples du chapitre Algèbre de boole
a | b | c | S |
---|---|---|---|
0 | 0 | 0 | 1 |
0 | 0 | 1 | 0 |
0 | 1 | 0 | 0 |
0 | 1 | 1 | 0 |
1 | 0 | 0 | 1 |
1 | 0 | 1 | 0 |
1 | 1 | 0 | 1 |
1 | 1 | 1 | 1 |
La fonction est S=f(0,4,6,7).
a | b | c | S |
---|---|---|---|
0 | 0 | 0 | 1 |
0 | 0 | 1 | 0 |
0 | 1 | 0 | 0 |
0 | 1 | 1 | 0 |
1 | 0 | 0 | 1 |
1 | 0 | 1 | 0 |
1 | 1 | 0 | 1 |
1 | 1 | 1 | 1 |
a | b | c | S |
---|---|---|---|
0 | 0 | 0 | 0 |
0 | 0 | 1 | 0 |
0 | 1 | 0 | 0 |
0 | 1 | 1 | 1 |
1 | 0 | 0 | 0 |
1 | 0 | 1 | 1 |
1 | 1 | 0 | 1 |
1 | 1 | 1 | 1 |
La fonction est S=f(3,5,6,7).
a | b | c | S |
---|---|---|---|
0 | 0 | 0 | 0 |
0 | 0 | 1 | 0 |
0 | 1 | 0 | 0 |
0 | 1 | 1 | 1 |
1 | 0 | 0 | 0 |
1 | 0 | 1 | 1 |
1 | 1 | 0 | 1 |
1 | 1 | 1 | 1 |
a | b | c | d | S |
---|---|---|---|---|
0 | 0 | 0 | 0 | 1 |
0 | 0 | 0 | 1 | 0 |
0 | 0 | 1 | 0 | 1 |
0 | 0 | 1 | 1 | 0 |
0 | 1 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 0 |
0 | 1 | 1 | 0 | 0 |
0 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 0 | 1 |
1 | 0 | 0 | 1 | 0 |
1 | 0 | 1 | 0 | 1 |
1 | 0 | 1 | 1 | 0 |
1 | 1 | 0 | 0 | 1 |
1 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 0 | 1 |
1 | 1 | 1 | 1 | 1 |
La fonction est S=f(0,2,8,10,12,13,14,15).
puis demander une
Le multiplexeur permet de fournir une solution logique directement à partir de la table de vérité. Pour cela il suffit de connecter les variables d'entrée de la table de vérité aux entées d'adresses du multiplexeur. Pour chaque entrée présente dans la fonction, il suffit de connecter l'entrée correspondante à 1 et les autres entrées à 0 pour reproduire la table de vérité.
Les exemples suivants sont repris des exemples du chapitre Algèbre de boole
a | b | c | S |
---|---|---|---|
0 | 0 | 0 | 1 |
0 | 0 | 1 | 0 |
0 | 1 | 0 | 0 |
0 | 1 | 1 | 0 |
1 | 0 | 0 | 1 |
1 | 0 | 1 | 0 |
1 | 1 | 0 | 1 |
1 | 1 | 1 | 1 |
La fonction est S=f(0,4,6,7).
a | b | c | S |
---|---|---|---|
0 | 0 | 0 | 0 |
0 | 0 | 1 | 0 |
0 | 1 | 0 | 0 |
0 | 1 | 1 | 1 |
1 | 0 | 0 | 0 |
1 | 0 | 1 | 1 |
1 | 1 | 0 | 1 |
1 | 1 | 1 | 1 |
La fonction est S=f(3,5,6,7).
a | b | c | d | S |
---|---|---|---|---|
0 | 0 | 0 | 0 | 1 |
0 | 0 | 0 | 1 | 0 |
0 | 0 | 1 | 0 | 1 |
0 | 0 | 1 | 1 | 0 |
0 | 1 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 0 |
0 | 1 | 1 | 0 | 0 |
0 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 0 | 1 |
1 | 0 | 0 | 1 | 0 |
1 | 0 | 1 | 0 | 1 |
1 | 0 | 1 | 1 | 0 |
1 | 1 | 0 | 0 | 1 |
1 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 0 | 1 |
1 | 1 | 1 | 1 | 1 |
La fonction est S=f(0,2,8,10,12,13,14,15).
puis demander une
Ces méthodes de synthèses ne sont plus utilisées directement, mais laisse la place aux logiciels de conception des circuits intégrés numériques : les ASICs et FPGA qui utilise un langage de haut niveau comme VHDL. La méthode qui met en oeuvre le multiplexeur, peut éventuellement être utilisée, dans le cas où les logiciels de conception acceptent une saisie de type schéma de la fonction à mettre en oeuvre.