05 La Logique Combinatoire

LA LOGIQUE COMBINATOIRE
La combinaison de portes logiques donne un circuit logique.

Cette logique combinatoire concerne l’étude des fonctions
logiques dont la valeur de sortie ne dépend que de l’état
logique des variables d’entrée.
A partir de la logique combinatoire il est possible de réaliser
les fonctions les plus courantes que sont: l’addition binaire,
le décodage, le multiplexage, le démultiplexage, la
conversion analogique-digitale et la conversion digitale-
analogique.
1
Le demi-additionneur
Un additionneur est un circuit logique permettant de réaliser une addition. Ce circuit est très présent dans les ordinateurs
pour le calcul arithmétique mais également pour le calcul d'adresses, d'indice de tableau dans le processeur.
Pour additionner deux nombres, il faut d’abord additionner les 2 bits de poids faible a0 et b0, puis additionner les bits
suivants sans oublier les retenues.
Un demi-additionneur ou Half Adder (HA) est un circuit qui additionne les 2 bits de poids faibles pour lesquelles la
retenue propagée n’est pas prise en compte.
Table de vérité, forme canonique et schéma
A B Somme Carry S = A’B+AB’ = S=A xor B = A B C=A.B
0 0
0 0 Dans cette table de vérité, nous reconnaissons la fonction OU exclusif
pour la somme et la fonction ET pour la retenue.
0 1
1 0
1 0
1 0
1 1
0 1
2
Un demi-additionneur utilisant des portes NAND
3
Un demi-additionneur utilisant des portes NOR
4
Additionneur complet d’1 bit

Pour additionner les bits de poids supérieur ai, bi (0 < i < n) et de tenir compte de la retenue ri-1
propagée depuis le rand i-1, il faut recours à un Full Adder ou additionneur complet. Un Full Adder peut
additionner 2 bits avec un report, soit trois entrées et deux sorties.
Un additionneur complet nécessite une entrée supplémentaire : une retenue. L'intérêt de celle-ci est de
permettre le chaînage des circuits. La table de vérité d'un additionneur complet est :
Table de vérité, forme canonique et schéma
A B Cin S Cout
=R =C
0 0 0 0 0 S=A’B’R+A’BR’+AB’R’+ABR = R’(A xor B) + R (AB+A’B’)
0 0 1 1 0 R’(A xor B) + R (AB+A’B’) = R’ (A xor B) + R (A xor B)’ = R xor A xor B
0 1 0 1 0 C= R(A’B+AB’)+ AB(R’+R) = R (A xor B)+ AB
0 1 1 0 1 R= Cin (Carry in) et C= Cout (Carry out)
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1
5
Additionneur complet d’1 bit A B Cin S Cout

=R =C S ഥ 𝐂ത 𝐁
𝐁 ഥC BC B ഥ𝐂
Nous pouvons à partir de la table de Karnaugh 0 0 0 0 0 (ABC)
optimiser les schéma de l’additionneur complet
0 0 1 1 0 ഥ
𝐀
0
1 1 3
2 1
0 1 0 1 0 A
La somme présente une configuration d’un jeu 4 1 5
7 1 6
d’échec. Il n’est donc pas possible de faire une 0 1 1 0 1

quelconque combinaison.
1 0 0 1 0
Dans ce cas S = A xor B xor Cin Cout ഥ 𝐂ത 𝐁
1 0 1 0 1 (ABC)
Pour la retenue Cout, nous pouvons faire deux 1 1 0 0 1 ഥ

𝐀
0 1
3 1 2
types de regroupement. Le premier qui nous vient 1 1 1 1 1 A

à l’esprit est de regrouper (7,5), (3,7) et (6,7), ce 4 5 1 7 1 6 1
qui va nous donner AB+AC+BC
Pour simplifier les schéma, nous pouvons
regrouper (7,6) et isoler 3 et 5, cela nous donne
ഥ Cin+ 𝐀
Cout = AB+ A 𝐁 ഥ BCin = AB+Cin(A xor B)
6
Additionneur complet d’1 bit utilisant 2 Half Adder

S = A xor B xor Cin Cout = AB+Cin(A xor B)
A xor B
S = A xor B xor Cin
Cin
AB
Cin (A xor B)
Cout = AB+Cin (A xor B)
Cin
7
Additionneur complet d’1 bit utilisant des portes NAND

S = A xor B xor Cin Cout = AB+Cin(A xor B)
8
Additionneur complet de n bits ou Additionneur en parallèle (Binary Parallel Adder)
L'addition de nombres comptant plusieurs bits peut se faire en série (bit après bit) ou en parallèle (tous les bits simultanément).
Nous allons prendre l'exemple d'un additionneur 4 bits comptant quatre "Full Adders", montés en parallèle ou en cascade. Chaque
additionneur FAi est affecté à l'addition des bits de poids i. L'entrée correspondant au report de retenue pour FA0 est imposée à 0 (en
logique positive). La retenue finale C indique un dépassement de capacité si elle est égale à 1.
Pour réaliser un additionneur complet de 2 nombres on met en cascade plusieurs FA de telle sorte que la retenu de sortie des bits moins
significatifs (LSB) constituent le retenus d’entrée des bits plus significatifs (MSB).
1 1 1 1 A3 (1) A2 (1) A1 (1) A0 (1)

0 1 1 1 B3 (0) B2 (1) B1 (1) B0 (1)
1 0 1 1 0
1 0 1 1 1 1 1 0
9
Additionneur complet de n bits ou Additionneur en parallèle (Binary Parallel Adder)
Si le dernier bit de retenue est égal à 1, il est signalé par un indicateur de carry mémorisé par un 1 noté C
(Carry) dans un registre appelé le Processor Status Word (PSW) ou registre d’etat.
Si le résultat est aussi en dehors de l’intervalle des n bits, ce dépassement de capacité est aussi mémorisé
dans le registre d’état du PSW par l’intermédiaire d’un bit 1 noté O (Overflow)
10
Construction d’un Half Adder utilisant les
circuit intégré AND et XOR
La somme d’une HA sorte par une porte

XOR et la retenue par une porte AND. Nous
pouvons à partir des circuits intégrés AND
(7408) et XOR (7486), réaliser le montage
d’un HA.
Il est aussi possible d’avoir un HA sous

forme de circuit intégré déjà monté. Il suffit
simplement de l’utiliser dans un schéma
plus global.
11
Circuit Intégré représentant un Full Adder
Du fait de leur utilisation courante, les constructeurs de
CI comme Motorola, Texas Instrument, Intel, etc.,
mettent sur le marché des circuit représentant des HA et
des FA prêt à être utilisés.
Parmi ces FA, nous pouvons citer le SN54/74LS83A. Ce
CI est un additionneur complet de 4 bits (A1, A2, A3, A4),
(B1, B2, B3, B4) qui génère une somme binaire dans
quatre sorties (S1, S2, S3, S4) et une retenue finale C4.
12
Comment obtenir un additionneur de 8 bits à partir de deux additionneurs de 4 bits
A7 A6 A5 A4 B7 B6 B5 B4 A3 A2 A1 A0 B3 B2 B1 B0
COUT
C7 Additionneur 4 bits C3 Additionneur 4 bits CIN
S7 S6 S5 S4 S3 S2 S1 S0
13
14
Le demi- soustracteur
Un demi-soustracteur ou Half Substractor (HS) est un circuit qui peut faire la soustraction de 2 bits.
A B Soustracteur Carry
0 0
0 0
0 1
1 1
1 0
1 0
S= A xor B C = A’B
1 1
0 0
15
Le demi- soustracteur utilisant des portes NAND
16
Le demi- soustracteur utilisant des portes NAND
17
Le soustracteur complet d’un bit A B C D R=
Bor in Bor ou
D ഥ 𝐂ത 𝐁
Comme dans le cas de l'addition, un pas élémentaire 0 0 0 0 0
(ABC)
dans une soustraction consiste à calculer la soustraction
0 0 1 1 1
de trois bits (où deux bits viennent des deux nombres à
ഥ
𝐀
0
1 1 3
2 1
soustraire, le troisième correspondant à la retenue
produite par le pas précédent). Il nous faut donc un 0 1 0 1 1 A
circuit à trois entrées A, B et C et deux sorties S et R,
4 1 5
7 1 6
0 1 1 0 1
calculant A - B - C et produisant le bit de différence S et
le bit de retenue R. Comme pour l'addition, on peut 1 0 0 1 0
obtenir ce circuit en utilisant deux copies du circuit R ഥ 𝐂ത 𝐁
demi-soustracteur : une copie ôte B de A, l'autre ôte C 1 0 1 0 0 (ABC)
du résultat produit par la première copie. Comme pour
l'addition, la retenue totale est égale à 1 si l'une des 1 1 0 0 0 ഥ
𝐀
0
1 1 3 1 2 1
copies fournit une retenue égale à 1. On obtient A
finalement un soustracteur complet. 1 1 1 1 1 4 5
7 1 6
La différence D présente une configuration de jeu

d’échec. Il n’est donc pas possible de faire une
quelconque combinaison.
Dans ce cas D = A xor B xor C
ഥB+𝐀
R = B C+𝐀 ഥC
18
Le soustracteur complet d’un bit utilisant des portes NAND
19
Le soustracteur complet d’un bit utilisant des portes NOR
20
Multiplicateur de 2 bits utilisant des Half Adder
Pour multiplier deux nombre A et B de 2 bits, nous procédons
comme suit : A (A0, A1) et B(B0, B1)
La multiplication de A et B de 2 bits va donner comme produit un A0 P0= A0B0
nombre P (P0P1P2P3) de quatre bits
B0
A1 A0
X A1 A1B0 P1 = A1B0+A0B1
B1 B0 B0
_______________________________________________
(C2) (C1) A1B0 A0B0 P2 = A1B1+C1
(C1)
A1B1 A0B1
_______________________________________________ A0B1
A1B1+C1 A1B0+A0B1 A0B0 A0
(C2) (C2) (C1) B1
P0 = A0B0 P0 = NAND(A0B0 )
P1 = A1B0+A0B1 P1 = HA (A1B0+A0B1 ) A1 A1B1 P3 = (C2)
P2 = A1B1+C1 P2 = HA (A1B0+A0B1 )
B1
P3 = (C2) P3 = (C2)
NB. Ne pas confonde le « + » HA avec l’opérateur OU

21
Carry Look Ahead Adder
Pour nous permettre d’additionner plus rapidement et éviter les délais de
propagation, nous pouvons remplacer le Full Adder classique par un additionneur qui
A B Cin C0
donne la retenue par anticipation, c’est que nous appelons CLA.
Au lieu d’attendre que la somme se fasse pour ensuite déterminer la retenue, nous
allons prévoir la retenue.
0 0 0 0
Dans la table de vérité qui se trouve à droite, nous ne intéréssons que de la retenue 0 0 1 0
finale C0 qui est l’objet de cette étude.
Si nous regardons la table de vérité, vous remarquerez que les deux dernières
retenues ne dépendent que de A et de B qui sont égale à 1, la valeur de Cin n’a aucune 0 1 0 0
influence sur la valeur de C0. Si nous avons A.B=1, nous avons C0 = 1
Nous pouvons appeler G=A.B est le générateur de retenu.
0 1 1 1
Par contre pour les deux autres retenues qui se trouvent sur la bande verte elles
dépendent de Cin qui doit être égale à 1, mais aussi de la valeur de A et de B qui
doivent êtres complémentaires.
1 0 0 0
Si nous avons 𝑨 ⊕ 𝑩 =1 et Cin =1 nous avons C0=1, 𝑨 ⊕ 𝑩 .Cin
Nous pouvons appeler P= 𝑨 ⊕ 𝑩 , le propagateur de retenue. 1 0 1 1
En combinant ces deux équations nous aurons
C0 = (A.B) + (𝑨 ⊕ 𝑩 .Cin) = G+P.Cin 1 1 0 1
La généralisation de l’équation donne Ci = (A.B) + (𝑨 ⊕ 𝑩 .Ci-1) = G+P.Ci-1
Ci = Gi+Pi.Ci-1 1 1 1 1
22
Carry Look Ahead Adder
Ci = Gi+Pi.Ci-1 G3 C3
CLA LOGIC
P3
P3
Nous allons chercher les valeur de C0, C1, C2, C3 en fonction G0=A0.B0 G2 C2 S3
de C-1 qui est la retenue initiale. P2
G1=A1.B1 P2
G2=A2.B2 G1 C1 S2
si i =0, C0 = G0+P0.C-1 P1
G3=A3.B3 P1
si i =1, C1 = G1+P1.C0,
G3=A3.B3 G0 C0 S1
P0
Nous remplaçons C0 par sa valeur pour ne rester qu’avec C-1
si i =1, C1 = G1+P1. (G0+P0.C-1) = G1+P1G0+P1P0.C-1 P0= 𝑨𝟎 ⊕ 𝑩𝟎 P0
C-1 C1 S0
P1= 𝑨𝟏 ⊕ 𝑩𝟏
si i =2, C2 = G2+P2.C1, = G2+P2.C1 = G2+P2 (G1+P1G0+P1P0.C-1 ) P2= 𝑨𝟐 ⊕ 𝑩𝟐
si i =2, C2 = G2+P2 G1+ P2 P1G0+ P2 P1P0.C-1 P3= 𝑨𝟑 ⊕ 𝑩𝟑
si i =3, C3 = G3+P3.C2
S3 = A3+B3+C2
si i =3, C3 = G3+P3. (G2+P2 G1+ P2 P1G0+ P2 P1P0.C-1 )
si i =3, C3 = G3+P3.G2+ P3 P2 G1+ P3 P2 P1G0+ P3 P2 P1P0.C-1
Nous remarquerons que la valeur de la retenue Ci , quelque

soit sa position est toujours fonction de Pi, de Gi et de C-1
23
Le soustracteur de 4 bits
Il suffit ensuite de relier entre elles n
copies de ce circuit soustracteur pour
pouvoir soustraire deux nombres de n
bits (comme avec l'addition, la copie la
plus à droite est en fait un demi
soustracteur, car la retenue initiale est
nulle).
24
L’additionneur / soustracteur binaire
Un additionneur soustracteur produit

une addition ou une soustraction de 4
bits. Il fonctionne presque comme un
additionneur ou ou soustracteur.
Les opérations d'addition et de
soustraction peuvent être effectuées
par un circuit binaire commun. Un tel
circuit binaire peut être conçu en
ajoutant une porte XOR à chaque
additionneur complet. Les entrées A3,
A2, A1 et A0 attaquent directement le
HA et les entrés B3, B2, B1 et B0
passent par des portes XOR qui ont
aussi une entrée commune M.
Cette ligne de contrôle détermine le
type d'opération. Lorsque M=1, le
circuit est un soustracteur et quand
M=0, le circuit devient un additionneur.
25
Additionneur BCD
Décimale Binaire BCD
Pour additionner deux nombre BCD, il faut considérer les 3 cas
suivants: C* S3* S2* S1* S0* C S3 S2 S1 S0
La somme ne dépasse pas 9 et la retenue est égale à 0, dans ce cas 0 0 0 0 0 0 0 0 0 0 0
l’addition se fait comme en binaire pur et le résultat obtenu est correct. 1 0 0 0 0 1 0 0 0 0 1
La partie blanche de la figure.
2 0 0 0 1 0 0 0 0 1 0
La somme ne dépasse pas 9 et la retenue est égale à 1, dans ce cas
l’addition se fait comme en binaire pur mais le résultat obtenu est 3 0 0 0 1 1 0 0 0 1 1
incorrect. Pour arriver au bon résultat, il faut additionner 6 (0110) au 4 0 0 1 0 0 0 0 1 0 0
résultat provisoire. La partie jaune de la figure
5 0 0 1 0 1 0 0 1 0 1
La somme dépasse 9 et la retenue est égale à 0, dans ce cas
l’addition se fait comme en binaire pur mais le résultat obtenu est 6 0 0 1 1 0 0 0 1 1 0
incorrect. Pour arriver au bon résultat, il faut additionner 6 (0110) au 7 0 0 1 1 1 0 0 1 1 1
résultat provisoire. La partie bleue de la figure.
8 0 1 0 0 0 0 1 0 0 0
Pour implémenter le circuit qui permet d’ajouter le « 0110 », nous
voyons que la retenue C* de la partie jaune est égale à 1, C*=1. 9 0 1 0 0 1 0 1 0 0 1
10 0 1 0 1 0 1 0 0 0 0
Pour la partie bleue, nous savons que le résultat est supérieur à 9,
mais la retenue n’est pas égale à 1, nous devons toujours ajouter 11 0 1 0 1 1 1 0 0 0 1
« 1001 ». (S3*=1) et (S2*=1 ou S1*=1), S3*.(S2*+S1*) 12 0 1 1 0 0 1 0 0 1 0
Pour la partie verte, nous savons que le résultat est supérieur à 9, 13 0 1 1 0 1 1 0 0 1 1
mais la retenue n’est pas égale à 1, nous devons toujours ajouter
« 1001 ». S3*=1 et S1*=1, S3*.S1*=1 Ce qui nous donne 14 0 1 1 1 0 1 0 1 0 0
l’expressions suivante: 15 0 1 1 1 1 1 0 1 0 1
C*+ S3*.(S2*+S1*)+ S3*.S1* 16 1 0 0 0 0 1 0 1 1 0
C*+ S3*.S2*+ S*3.S*1*+ S3*.S1* = C*+ S3*.S2*+ S*3.S*1* 17 1 0 0 0 1 1 0 1 1 1
Nous aurons besoin de deux portes ET et d’une porte OU qui va 18 1 0 0 1 0 1 1 0 0 0
attaquer le deuxième additionneur de 4 bits. 19 1 0 0 1 1 1 1 0 0 1
Retenue
C* Additionneur de 4 bits
Somme Binaire S3* S2* S1* S0*
0 1/0 1/0 0
Additionneur de 4 bits
C S3 S2 S1 S0
Retenue Somme BCD

Le Comparateur
On rencontre très souvent la nécessité de comparer deux entiers (A = B, A > B ou A < B).
La table de vérité correspondant à ces trois fonctions de comparaison de 2 bits. La fonction C doit être
égale à 1 si et seulement si A > B, la fonction D=1 si et seulement si A < B et la fonction E=1 si et
seulement si A = B. Ce qui nous donne :
A B C D E C=AB’ D=A’B E=A nxor B = (AB’+ A’B)’ = (C+D)’

(A>B) (A<B) (A=B)
0 0 0 0 1
0 1 0
0 1
1 0 0
1 0
1 1 0 0 1
Le Comparateur de 3 bits
Le comparateur de 3 bits est une association de comparateurs d’un bit, les sorties S1, E1, I1, du 1er
comparateur d’un bit a sont reliées aux entrées S1, E1 et I1 du 2ème comparateur.
Brochage et schéma du
comparateur 7485
Brochage et schéma du
comparateur 7485
Le Contrôleur de parité A B C D P
Les transmissions en série binaires font parties des 0 0 0 0 0 ABCD ഥ𝐁
𝑨 ഥ ഥB
𝑨 AB ഥ
A𝐁
techniques les plus utilisées. Cette transmission entre
l’émetteur et le récepteur peut être câblées ou non. 0 0 0 1 1
Dans ce mode de transmission, les erreurs de données 0 0 1 0 1

𝐂ത 𝐃ഥ 0 1 1 3 2 1
sont l'un des problèmes les plus importants qui doivent
être analysés pour obtenir un système de communication 0 0 1 1 0 𝐂ത D 4 1 5 7 1 6
fiable. 0 1
0 1 0 CD 12 13 1 15 14 1
La méthode de génération/vérification de parité est l'une 0 1 0 1 0
des techniques de détection d'erreurs les plus utilisées Cഥ
𝐃 8 1 9 11 1 10
pour la transmission de données ; un bit de parité est 0 1 1 0 0
annexé aux données transmises pour faire en sorte que
la somme des données binaires des «1» soit pair ou 0 1 1 1 1
impair.
1 0 0 0 1
Ce bit est utilisé pour détecter les erreurs lors de la
transmission. 1 0 0 1 0
1 0 1 0 0
La parité d'un mot binaire est définie comme la parité de A
la somme des bits, soit encore : 1 0 1 1 1
A xor B
• parité paire (ou 0) : nombre pair de 1 dans le mot ; 1 1 0 0 0 B A xor B xor C
• parité impaire (ou 1) : nombre impair de 1 dans le mot. P=A xor B xor C xor D
1 1 0 1 1
Pas ce cases adjacents, donc non simplifiable par C
Karnaugh. 1 1 1 0 1
D
P=A’B’C’D+ A’B’CD’+ A’BC’D’+ A’BCD+ ABC’D+ ABCD’+ AB’C’D’+ AB’CD 1 1 1 1 0
A xor B xor C xor D
32
Le Contrôleur de parité
La fonction OU-exclusif donne la parité d'un
sous-ensemble de deux bits.
La figure suivante représente le diagramme

logique d'un générateur/contrôleur de parité
pour 4 bits.
Si l'entrée P' est imposée à 0 ce circuit
fonctionne comme générateur de parité : la
sortie P représente la parité du mot
composé par les bits A, B, C et D.
Pas ce case adjacent, donc non simplifiable par
Karnaugh
P=A’B’C’D’+ A’B’CD+ A’BC’D+ A’BCD’+ AB’C’D+
AB’C’D+ ABC’D’+ ABCD
(A xor B) xor (C xor D) xor P’ = P
33
A B C D P
0 0 0 0 0 A’B’ A’B AB AB’
0 0 0 1 1
0 0 1 0 1
C’D’ 1 1
0 0 1 1 0 C’D 1 1
1 1
0 1 0 0 1
CD
0 1 0 1 0
0 1 1 0 0 CD’ 1 1
0 1 1 1 1
1 0 0 0 1 Cette configuration est appelée Check Board Configuration
1 0 0 1 0
En regardant le tableau de Karnaugh, vous vous rendez compte que
1 0 1 0 0 les cellules ne sont pas adjacentes, donc pas simplifiable
1 0 1 1 1 graphiquement. Nous allons dons essayer de minimiser l’équation
par la méthode algébrique.
1 1 0 0 0
1 1 0 1 1 Le POS s’écrit comme suit :
1 1 1 0 1 P=A’B’C’D+A’B’CD’+A’BC’D’+A’BCD+AB’CD+ABC’D+ABCD’
1 1 1 1 0
34
Le codeur
Un codeur permet de transmettre une information de la
meilleure façon. Cette transmission est souvent plus simple,
plus rapide et plus sécurisé. Les langues que nous utilisons
sont des codes. Les Codeurs sont utilisés pour la
compression des données.
Le principe de fonctionnement d’un codeur est le suivant :
lorsqu’une entrée est activée, les sorties affichent la valeur
correspondant au numéro de l’entrée dans le code binaire
choisi.
Un codeur peut être vu comme un convertisseur du code
décimal vers un code binaire. Une seule entrée du codeur
doit normalement être activée à la fois.
Dans le cas où le code en sortie est le code binaire pur, le
circuit correspondant possède N entrées et n sorties, avec
2n−1 < N ≤ 2n.
Codeur binaire 8 vers 3 (8 entrées vers 3 sorties)
Ce codeur reçoit une information codée sur une de ses 8
entrées et génère l’équivalent binaire sur les sorties S0, S1
et S2. Une seule entrée doit être active à la fois.
S0 = E1 + E3 + E5 + E7
S1 = E2 + E3 + E6 + E7
S2 = E4 + E5 + E6 + E7
Codeur binaire 16 vers 4
Ce codeur reçoit une

information codée sur une de
ses 16 entrées et génère
l’équivalent binaire sur les 4
sorties S0 à S3.
Une seule entrée doit être
active à la fois.
S0 = E1+E3+E5+E7+E9+E11+E13+E15
S1 = E2+E3+E6+E7+E10+E11+E14+E15
S2 = E4+E5+E6+E7+E12+E13+E14+E15
S3 = E8+E9+E10+E11+E12+E13+E14+E15
Le décodeur
A B S0 S1 S2 S3
Dans un système numérique les instructions, tout comme les nombres, sont transportées sous
forme de mots binaires. Par exemple un mot de 4 bits peut permettre d'identifier 16 instructions
différentes : l'information est codée. Très souvent l'équivalent d'un commutateur à 16 positions 0 0 1 0 0 0
permet de sélectionner l'instruction correspondant à un code. Ce processus est appelé
décodage. 0 1 0 1 0 0
Le décodeur réalise la fonction inverse du codeur. C’est un circuit logique comportant n 1 0 0 0 1 0
entrées et 2n sorties. Lorsque le signal de validation est actif, seule la sortie dont le
numéro correspond à la valeur binaire affichée sur l’entrée est active. Toutes les autres 1 1 0 0 0 1
sont inactives.
Nous pouvons citer comme exemple le clavier d’une porte automatique ou le décodeur
BCD/Afficheur 7 segments.
Le décodeur est un circuit très employé dans les microprocesseurs. Son rôle est de
sélectionner entre autres, une adresse précise de mémoire parmi un lot important
d’adresses différentes.
Si nous voulons aller chercher dans une mémoire d’une capacité de 4096 mots, un mot
donné situé à une adresse bien précise. Il n’est pas question d’adresser les 4096 mots
différents contenus dans la mémoire. Cela nécessiterait 4096 fils. Pour résoudre ce
problème il ne faut relier le microprocesseur que par 12 fils, car c’est un mot de 12 bit qui
permet d’adresser 4096 place (2 12 = 4096). Il nous faudra alors un décodeurs 12
entrées et 4096 sorties.
S0 = A’B’ S1=A’B S2 = AB’ S3=AB
Le décodeur LED de 7 segments
Il nous arrive de vouloir représenter des chiffres de
0 à 9 en utilisant un LED de 7 segments.
Minterm Décimal w x y z a b c d e f g
m0 0 0 0 0 0 1 1 1 1 1 1 0
m1 1 0 0 0 1 0 1 1 0 0 0 0
m2 2 0 0 1 0 1 1 0 1 1 0 1 a
m3 3 0 0 1 1 1 1 1 1 0 0 1
m4 4 0 1 0 0 0 1 1 0 0 1 1
m5 5 0 1 0 1 1 0 1 1 0 1 1 f b
m6 6 0 1 1 0 1 0 1 1 1 1 1 g
m7 7 0 1 1 1 1 1 1 0 0 0 0
m8 8 1 0 0 0 1 1 1 1 1 1 1
m9 9 1 0 0 1 1 1 1 1 0 1 1 e c
m10 1 0 1 0
m11 1 0 1 1
m12 1 1 0 0 Don't cares d
m13 1 1 0 1 Non utilisé
m14 1 1 1 0
m15 1 1 1 1
0
1
1
0 yz
wx
00 01 11 10
00 m0 = 1 m1
2 1
m3=1 m2 =1
3 1
01 m4
4 0
m5=1 m7=1 m6 =1
5 1
11 m12= xm13=x m15=x m14=x
6 1
7 1
8
9
1
1
10 m8=1 m9=1 m11=x m10=x
Le décodeur LED de 7 segments

Il nous arrive de vouloir représenter des chiffres de
0 à 9 en utilisant un LED de 7 segments.
00 01 11 10 00 01 11 10 00 01 11 10 00 01 11 10
0 1 wx 0 1 wx 0 1 wx 0 1 wx
1 0 yz 1 1 yz 1 1 yz 1 0 yz
2
3
1
1
00 m0 = 1 m1 m3=1 m2 =1
2
3
1
1
00 m0 = 1 m1 =1 m3=1 m2 =1
2
3
0
1
00 m0 = 1 m1=1 m3=1 m2
2
3
1
1
00 m0 = 1 m1 m3=1 m2 =1
4
5
0
1
01 m4 m5=1 m7=1 m6 =1
4
5
1
0
01 m4 =1 m5 m7=1 m6
4
5
1
1
01 m4 =1 m5=1 m7=1 m6 =1
4
5
0
1
01 m4 m5=1 m7 m6 =1
11 m12= xm13=x m15=x m14=x 11 m12= xm13=x m15=x m14=x 11 m12= xm13=x m15=x m14=x 11 m12= xm13=x m15=x m14=x
6 1 6 0 6 1 6 1
7 1 7 1 7 1 7 0
8
9
1
1
10 m8=1 m9=1 m11=x m10=x
8
9
1
1
10 m8=1 m9=1 m11=x m10=x
8
9
1
1
10 m8=1 m9=1 m11=x m10=x
8
9
1
1
10 m8=1 m9=1 m11=x m10=x
a=x'z'+xz+w+y = x xnor z +w+y b=y+w'x'+wx+z' c=y+z+w'+x d=yz'x'+wz'+w'xz
0
1
1
0 yz
wx
00 01 11 10 0
1
1
0 yz
wx
00 01 11 10 0
1
0
0 yz
wx
00 01 11 10
2
3
1
0
00 m0 = 1 m1 m3 m2 =1
2
3
0
0
00 m0 = 1 m1 m3 m2 =1
2
3
1
1
00 m0 m1 m3=1 m2 =1
01 m4 01 m4 =1 m5=1 01 m4 =1 m5=1
4 0 4 1 4 1
m5 m7 m6 =1 m7 m6 =1 m7 m6 =1
5 0 5 1 5 1
6
7
1
0
11 m12= xm13=x m15=x m14=x 6
7
1
0
11 m12=x m13=x m15=x m14=x 6
7
1
0
11 m12= xm13=x m15=x m14=x
10 m8=1 10 m8=1 10 m8=1
8 1 8 1 8 1
m9 m11=x m10=x m9=1 m11=x m10=x m9=1 m11=x m10=x
9 0 9 1 9 1
e = z'x'+wx' f= y+x'z+x'z+w'x' g=y+wz+wx'+z'w
Décodeur 3 vers 8 (3 entrées et 8 sorties)
La fonction d’un décodeur est de reconnaître une
combinaison de bits en entrée (le code) et de signaler
la présence de ce code en mettant un signal en sortie
à 1.
Si nous nous cherchons à reconnaître le code binaire
1001, Dans ce cas, il faut réaliser un circuit qui
implémente la fonction R = x3.x2.x1.x0. On remarque
que R = 1 si l’entrée est 1001 et 0 sinon, ce circuit
permet de décoder le code 1001.
Décodeur BCD - Décimal
Le code DCB (Décimal Codé Binaire) (ou en anglais BCD : Binary
Coded Decimal) transforme les nombres décimaux en remplaçant
chacun des chiffres décimaux par 4 chiffres binaires. Cette
représentation conserve donc la structure décimale : unités, dizaines,
centaines, milliers, etc… Chaque chiffre est codé sur 4 bits.
Par exemple le nombre décimal 294 sera codé en DCB : 0010 1001
0100. Ce type de codage permet de faciliter l'affichage en décimal du
contenu d'un compteur. Pour ce faire on peut utiliser des afficheurs
lumineux à sept segments.
La fonction de chacun des transcodeurs est de positionner à 1 les
lignes de sortie correspondant aux segments à allumer selon de code
porté par les quatre lignes d'entrée. De manière générale, un
transcodeur fait correspondre à un code A en entrée sur n lignes, un
code B en sortie sur m lignes.
Nous allons étudier l'exemple d'un décodeur DCB-décimal.
A chacune des lignes de sortie nous pouvons associer un produit
prenant en compte chacune des quatre entrées ou leur complément.
Ainsi la ligne 5 correspond à : A’ B C’D
D'autre part, on souhaite souvent n'activer les lignes de sortie qu'en
présence d'un signal de commande global (strobe ou enable). Ce
signal S est mis en coïncidence sur chacune des dix portes de sortie.
Dans l'exemple suivant, si S est dans l'état 0 le décodeur est bloqué et
toutes les sorties sont également dans l'état 0.
Le transcodeur
Un transcodeur (ou convertisseur de codes) est un dispositif permettant de passer du nombre N écrit dans le code C1 au
même nombre N écrit dans le code C2. Il comporte N entrées et N sorties.
Il n'existe pas un code binaire meilleur que tous les autres : aussi en utilise-t-on plusieurs avec des transcodeurs pour
passer de l'un à l'autre.
Leurs utilisations en nombres relativement limités expliquent qu'on ne les trouve pas tous sous forme de circuits intégrés :
il faut alors les réaliser à l'aide de portes logiques ET-NON, OU NON ... etc. la réalisation pratique d’un transcodeur passe
par l’écriture de sa table de vérité, puis par la recherche des équations de sorties avec les tableaux de Karnaugh.
Parmi les transcodeurs que l'on trouve en circuits intégrés, on peut citer :
• les transcodeurs décimal / BCD (circuit 74147).

• les transcodeurs BCD / décimal (circuits 7442, 7445, et 4028).
• les transcodeurs XS 3 / décimal (circuit 7443)
• les transcodeurs Gray excédant 3 (code Gray+3) / décimal (circuit 7444)
• les transcodeurs DCB /afficheur 7 segments (circuits 7448, 7511, 4543, 4511)
• les transcodeurs binaire 5 bits / DCB (circuit 74185).
• les transcodeurs DCB / binaire 5 bits (circuit 74184).
Le transcodeur 10 vers 4
Ce transcodeur reçoit un
chiffre décimal sur une des
dix entrées et génère
l’équivalent binaire sur les
Sorties S0 à S3. Une seule
entrée doit être active à la
fois.
S0 = E1 + E3 + E5 + E7 + E9
S1 = E2 + E3 + E6 + E7
S2 = E4 + E5 + E6 + E7
S3 = E8 + E9
Le transcodeur 4 vers 10
Ce transcodeur reçoit un
chiffre binaire sur une des 4
entrées et génère
l’équivalent décimal sur les
Sorties S0 à S9. Une seule
entrée doit être active à la
fois.
Le transcodeur 3 vers 3 (binaire pur-Gray)
Pour passer du code Gray au code binaire pur on utilise un
B0 B1 B2 G0 G1 G2
transcodeur.
Le code Gray est fréquemment utilisé dans les capteurs
angulaires ou de positionnement, mais aussi lorsque l'on
0 0 0 0 0 0
désire une progression numérique binaire sans parasite
transitoire. Il sert également dans les tableaux de Karnaugh 0 0 1 0 0 1
utilisés lors de la conception de circuits logiques.
Pour passer du code binaire au code Gray on utilise la 0 1 0 0 1 1
formule suivante :
0 1 1 0 1 0
n = N xor 2N
2 1 0 0 1 1 0
n est le nombre converti en Gray et N le nombre binaire.
1 0 1 1 1 1
Table de vérité pour passer du code binaire au code Gray.
• G0=B0B1’B2’+B0B1’B2+B0B1B2’+B0B1B2 1 1 0 1 0 1
• G1=B0’B1B2’+ B0’B1B2+B0B1’B2’+B0B1’B2 1 1 1 1 0 0
• G2=B0’B1’B2+ B0’B1B2’+B0B1’B2+B0B1B2’
Le transcodeur 4 vers 4 (binaire pur-Gray)
Nous pouvons remarquer que le passage du binaire pur
au code Gray se fait en effectuant une opération OU
Exclusif.
Le circuit du transcodeur est très simple. En désignant par
Bn (B1 = LSB) un bit quelconque en code binaire pur et
par Gn le bit recherché en code Gray, nous avons alors :
Gn = Bn xor Bn+1
Un encodeur E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 S3 S2 S1 S0
Un encodeur est système qui comporte N

1 0 0 0 0 0 0 0 0 0 0 0 0 0
lignes d’entré et n lignes de sorties.
Lorsqu’une des lignes d’entrée est activité 0 1 0 0 0 0 0 0 0 0 0 0 0 1
l’encodeur fournit en sortie un mot de n bits 0 0 1 0 0 0 0 0 0 0 0 0 1 0
correspondant au codage de l’information 0 0 0 1 0 0 0 0 0 0 0 0 1 1
identifié par la ligne activée. 0 0 0 0 1 0 0 0 0 0 0 1 0 0
Table de vérité d’un encodeur transformant un 0 0 0 0 0 1 0 0 0 0 0 1 0 1
nombre décimal en son équivalent en code 0 0 0 0 0 0 1 0 0 0 0 1 1 0
BCD. Il comporte 10 entrées et 4 sorties 0 0 0 0 0 0 0 1 0 0 0 1 1 1
0 0 0 0 0 0 0 0 1 0 1 0 0 0
• S0 = E1+E3+E5+E7+E9 0 0 0 0 0 0 0 0 0 1 1 0 0 1
• S1 = E2+E3+E6+E7
• S2 = E4+E5+E6+E7
• S3 = E8+E9
Un encodeur hexadécimal vers

binaire
Le Multiplexeur
Le multiplexeur aussi a pour rôle d’aiguiller sur une sortie unique un signal prélevé parmi plusieurs autres de nature
différentes. C’est en quelque sorte un circuit qui réalise la fonction inverse d’un décodeur.
Le multiplexeur est un dispositif qui permet de transmettre sur une seule ligne des informations en provenance de plusieurs
sources ou à destination de plusieurs cibles.
C’est un circuit comportant 2n entrées d’informations, n entrées d’adresse et une seule sortie. Lorsque la validation est
active la sortie prend l’état d’une entrée.
S= E’B’A’X0 + E’B’AX1+ E’BA’X2+ E’BAX3
B A E S
E
Entrée de Entrée de Entrée Sortie
Enable
Commande Commande d’information en fonction
Validation
ou d’adresse ou d’adresse des entrées
0 0 0 X0 E’B’A’X0
0 0 1 X1 E’B’AX1
0 1 0 X2 E’BA’X2
0 1 1 X3 E’BAX3
1 0 0 0 Rien ne se passe car E=1
Le Démultiplexeur
C’est le circuit complémentaire du multiplexeur. Il comporte une
entrée d’information, 2n sorties d’information et n entrées
d’adresse. Il met en relation cette entrée avec une sortie et une seule.
Pour pouvoir sélectionner cette sortie il faut également des lignes
d'adressage : le code porté par ces lignes identifie la ligne de sortie à
utiliser. Ce circuit est très proche d'un décodeur. Considérons un
démultiplexeur avec quatre lignes de sortie. Il faut deux lignes
d'adresse. Supposons que nous souhaitons également valider les
données avec un signal de contrôle E (pour laisser par exemple le
temps aux niveaux d'entrée de se stabiliser). Par convention nous
choisissons de prendre en compte les données pour E = 0.
Comme pour l’additionneur, il est possible de faire des cascades de
multiplexeur et de démultiplexeur pour avoir plusieurs entrées ou
plusieurs sorties.
Y0 = A’B’E’D
Y1= AB’E’D
Y2= A’BE’D
Y3= ABE’D
Construire un additionneur complet à partir d’un

décodeur 3 x 8
Le Démultiplexeur
Le Démultiplexeur
Le Démultiplexeur
Le Démultiplexeur

05 La Logique Combinatoire

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

05 La Logique Combinatoire

Transféré par

Droits d'auteur :

Formats disponibles

LA LOGIQUE COMBINATOIRE

La combinaison de portes logiques donne un circuit logique.

Un demi-additionneur utilisant des portes NAND

Un demi-additionneur utilisant des portes NOR

Additionneur complet d’1 bit

0 1 1 0 1 R= Cin (Carry in) et C= Cout (Carry out)

Additionneur complet d’1 bit A B Cin S Cout

d’échec. Il n’est donc pas possible de faire une 0 1 1 0 1

Pour la retenue Cout, nous pouvons faire deux 1 1 0 0 1 ഥ

types de regroupement. Le premier qui nous vient 1 1 1 1 1 A

Additionneur complet d’1 bit utilisant 2 Half Adder

Additionneur complet d’1 bit utilisant des portes NAND

1 1 1 1 A3 (1) A2 (1) A1 (1) A0 (1)

La somme d’une HA sorte par une porte

Il est aussi possible d’avoir un HA sous

La différence D présente une configuration de jeu

Le soustracteur complet d’un bit utilisant des portes NAND

Le soustracteur complet d’un bit utilisant des portes NOR

NB. Ne pas confonde le « + » HA avec l’opérateur OU

Nous remarquerons que la valeur de la retenue Ci , quelque

L’additionneur / soustracteur binaire

Un additionneur soustracteur produit

Somme Binaire S3* S2* S1* S0*

Retenue Somme BCD

A B C D E C=AB’ D=A’B E=A nxor B = (AB’+ A’B)’ = (C+D)’

Dans ce mode de transmission, les erreurs de données 0 0 1 0 1

La figure suivante représente le diagramme

Ce codeur reçoit une

11 m12= xm13=x m15=x m14=x

Le décodeur LED de 7 segments

a=x'z'+xz+w+y = x xnor z +w+y b=y+w'x'+wx+z' c=y+z+w'+x d=yz'x'+wz'+w'xz

• les transcodeurs décimal / BCD (circuit 74147).

Un encodeur est système qui comporte N

Un encodeur hexadécimal vers

Construire un additionneur complet à partir d’un

Vous aimerez peut-être aussi