Le comparateur logique
Un comparateur logique est un circuit logique, appelé aussi solution combinatoire ou circuits d'identification, permet de comparer deux nombres binaires $A$ et $B$ de $n$ bits. Le résultat permet de déterminer lequel des deux nombres est le plus grand, le plus petit ou égaux s'ils le sont.
Pour une comparaison mathématique simple, nous avons :
- A est égal à B si $A = B$
- A est supérieure à B si $A > B$
- A est inférieur à B si $A < B$
Si nous traduisons maintenant cette comparaison en logique binaire, par exemple pour comparer deux mots binaire chacun de 1 bit, nous pouvons écrire :
- $A = B \quad \Rightarrow \quad S_= = 1$
- $A > B \quad \Rightarrow \quad S_> = 1$
- $A < B \quad \Rightarrow \quad S_< = 1$
Symbole du comparateur logique
Pour modéliser un comparateur logique, nous pouvons l'assimiler à une boite noir pour l'instant avec 2 entrées et 3 sorties telle que :
- entrées : deux mots binaires de longueur 1 bit $A$ et $B$
- sorties : trois mots binaires de longueur 1 bit $S_=$ , $S_>$ et $S_<$ telles que :
- $S_> = 1$ si $A>B$.
- $S_= = 1$ si $A=B$
- $S_< = 1$ si $A<B$

Or, comme vous pouvez le constater, cette modélisation ne permet de comparer que deux mots binaire à 1 bit chacun.
Exemple : comparaison entre deux bits
Etudions ensemble ce premier comparateur entre deux bits $A$ et $B$, que nous venons de découvrir son symbole ci-dessus. Pour traduire son mode de fonctionnement, nous allons écrire ci-dessous sa table de vérité :
| $A$ | $B$ | $S_=$ | $S_>$ | $S_<$ |
| 0 | 0 | 1 | 0 | 0 |
| 0 | 1 | 0 | 0 | 1 |
| 1 | 0 | 0 | 1 | 0 |
| 1 | 1 | 1 | 0 | 0 |
Ce qui permet de nous écrire par la suite les équations logiques de ses 3 sorties $S_=$, $S_>$ et $S_<$ telles que :
- $S_> = A \cdot \bar{B}$
- $S_= = \bar {A} \cdot \bar{B} + A \cdot B = \overline{(A \oplus B)} = A \odot B$
- $S_< = A \cdot \bar{B}$
Le circuit logique d'un comparateur à 1 bit
Ainsi, nous pouvons établir le logigramme ci-dessous pour notre comparateur élémentaire entre deux bits comme suit :

Comparateur binaire à n bits
Pour comparer deux mots binaires $A$ et $B$ de longueur $n$ bits chacun, nous commençons par comparer les bits de poids forts, appelé aussi MSB, puis on passe aux bits de poids inférieurs en cas d'égalité jusqu'à ce que nous arrivons aux bits du poids faibles, appelé aussi LSB. Pour la comparaison des bits intermédiarires, nous allons appliquer le principe de comparaison ci-dessous :
- $A > B$ si $a_i > b_i$,
- $A < B$ si $a_i < b_i$,
- Si $ a_i = b_i$ alors on compare $a_{i-1}$ et $b_{i-1}$.
Donc en analysons comment fonctionne ce comparateur à $n$ bits, nous pouvons conclure que la comparaison se fait à un niveau élémentaire entre chaque fois le bit $a_i$ avec le bit $b_i$ tout en prenant en compte le résultat de la comparaison de l'étage supérieur $i+1$. Ce qui nous laisse imaginer le sympbole d'un comparateur élémentaire qui prend en charge le résultat de l'étage de comparaison supérieure $i+1$ (puisque la comparaison se fait toujours du MSB vers le LSB) :

Ainsi, pour réaliser un comparateur à $n$ bits, il nous suffit juste de cascader plusieurs étages de ce comparateur élémentaire pour réaliser la comparaison demandée.
Exemple : comparaison entre deux mots binaires à 2 bits
Logigramme fonctionnelle
Pour mieux comprendre ce principe, nous vous proposons de regarder la démarche à suivre pour comparer deux nombres A $(a_1,a_0)$ et B $(b_1,b_0)$ :

Comme vous pouvez le constater, on commence par comparer les deux bits de poids forts $a_1$ et $b_1$ et ensuite, on ne passe aux bits de poids inférieurs si $a_1 = b_1$.
Vous pouvez aussi conclure pour :
- $A$ est supérieur à $B$ ($A > B$) dans l'un des deux cas suivants :
- le bit $a_1$ est supérieur $b_1$ ($a_1 > b_1$).
- sinon, $a_1 = b_1$ et $a_0 > b_0$.
- $A$ est inférieur à $B$ ($A < B$) dans l'un des deux cas suivants :
- le bit $a_1$ est inférieur à $b_1$ ($a_1 < b_1$).
- sinon, $a_1 = b_1$ et $a_0 < b_0$.
- $A = B$ si et seulement $a_1 = b_1$ et $a_0 = b_0$.
Table de vérité
A partir de ce logigramme, écrivons la table de vérité de ce comparateur à deux bits :
| $a_1$ | $a_0$ | $b_1$ | $b_0$ | $S_=$ | $S_>$ | $S_<$ |
| 0 | 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 | 1 |
| 0 | 0 | 1 | 0 | 0 | 0 | 1 |
| 0 | 0 | 1 | 1 | 0 | 0 | 1 |
| 0 | 1 | 0 | 0 | 0 | 1 | 0 |
| 0 | 1 | 0 | 1 | 1 | 0 | 0 |
| 0 | 1 | 1 | 0 | 0 | 0 | 1 |
| 0 | 1 | 1 | 1 | 0 | 0 | 1 |
| 1 | 0 | 0 | 0 | 0 | 1 | 0 |
| 1 | 0 | 0 | 1 | 0 | 1 | 0 |
| 1 | 0 | 1 | 0 | 1 | 0 | 0 |
| 1 | 0 | 1 | 1 | 0 | 0 | 1 |
| 1 | 1 | 0 | 0 | 0 | 1 | 0 |
| 1 | 1 | 0 | 1 | 0 | 1 | 0 |
| 1 | 1 | 1 | 0 | 0 | 1 | 0 |
| 1 | 1 | 1 | 1 | 1 | 0 | 0 |
Equation logique
A partir de la table de vérité dressée ci-dessous, vous pouvez déterminer les équations logiques de chaque sortie $S_=$, $S_>$ et $S_<$ comme suit :
- $S_= = (\overline{a_1 \oplus b_1}) \cdot (\overline{a_0 \oplus b_0})$
- $S_> = (a_1 \cdot \overline{b_1}) + (\overline{a_1 \oplus b_1} \cdot a_0 \cdot \overline{b_0})$
- $S_< = (\overline{a_1} \cdot b_1) + (\overline{a_1 \oplus b_1} \cdot \overline{a_0} \cdot b_0)$