Le multiplexeur (MUX) démystifié : l’aiguilleur des données

En bref : un multiplexeur sélectionne l’une de $2^n$ entrées de données au moyen d’un code de sélection sur $n$ bits. Pour un MUX 4 vers 1, $Y=\overline{S_1}\overline{S_0}D_0+\overline{S_1}S_0D_1+S_1\overline{S_0}D_2+S_1S_0D_3$. Des constantes appliquées aux entrées de données transforment un MUX en réalisation d’une table de vérité, tandis que les véritables LUT de FPGA associent une configuration mémorisée à des circuits de sélection propres à leur architecture.

Les multiplexeurs sélectionnent les sources des opérandes dans les processeurs, les réponses dans les interconnexions et les signaux configurés dans la logique programmable. Les commutateurs analogiques et vidéo répondent à un problème d’acheminement apparenté, mais leur comportement électrique dépasse celui d’un MUX numérique à un bit. Ce guide traite des fondements booléens, de la construction au niveau des portes, de la mise en cascade et de la capacité à générer des fonctions.

Qu’est-ce qu’un multiplexeur ?

Un multiplexeur est un circuit combinatoire qui sélectionne l’une de plusieurs entrées de données et la transmet à une seule ligne de sortie. Cette sélection est commandée par un ensemble distinct de lignes de sélection, qui codent l’adresse binaire de l’entrée souhaitée.

Pour un MUX entièrement peuplé dont la taille est une puissance de deux :

$n$ lignes de sélection permettent de choisir parmi $2^n$ entrées de données.

Une ligne de sélection adresse deux entrées, deux lignes en adressent quatre et trois lignes en adressent huit. Dans une interface dont la taille n’est pas une puissance de deux, certains codes peuvent rester inutilisés ou désigner un chemin par défaut ; de nombreux composants pratiques ajoutent aussi une validation ou une entrée stroboscopique.

Un multiplexeur 4 vers 1 : deux lignes de sélection choisissent l’une des quatre entrées. L’entrée choisie apparaît à la sortie.

Le MUX 2 vers 1 : le sélecteur de données élémentaire

Le MUX 2 vers 1 est la brique fondamentale. Il possède deux entrées de données ($D_0$, $D_1$), une ligne de sélection ($S$) et une sortie ($Y$).

L’expression booléenne est directe. $D_0$ doit passer lorsque $S=0$, et $D_1$ lorsque $S=1$ :

$Y = \overline{S} \cdot D_0 + S \cdot D_1$

Une réalisation canonique avec des portes élémentaires utilise :

• une porte NON pour produire $\overline{S}$ ;
• deux portes ET : l’une calcule $\overline{S} \cdot D_0$, l’autre $S \cdot D_1$ ;
• une porte OU qui réunit les deux sorties ET pour former le résultat final.

Un MUX 2 vers 1 construit avec des portes ET, OU et NON. Lorsque S=0, $D_0$ passe ; lorsque S=1, $D_1$ passe.

Le MUX 4 vers 1 : expression booléenne et conception avec des portes

Un MUX 4 vers 1 possède quatre entrées de données ($D_0$ à $D_3$) et deux lignes de sélection ($S_1$, $S_0$). Ces dernières forment une adresse binaire de 2 bits qui choisit l’entrée transmise à la sortie.

Chaque ligne de ce tableau correspond à un terme produit dans lequel les lignes de sélection « valident » exactement une entrée de données. L’expression booléenne complète du MUX 4 vers 1 est :

$Y = \overline{S_1}\,\overline{S_0}\,D_0 + \overline{S_1}\,S_0\,D_1 + S_1\,\overline{S_0}\,D_2 + S_1\,S_0\,D_3$

Cette expression indique exactement le matériel nécessaire :

• 2 portes NON pour produire $\overline{S_1}$ et $\overline{S_0}$ ;
• 4 portes ET à trois entrées, chacune associant une entrée de données à la combinaison de sélection appropriée ;
• 1 porte OU à quatre entrées pour réunir les sorties des quatre portes ET.

Le schéma booléen direct contient deux inversions, quatre termes produits et une réduction OU. Compter « sept portes » suppose que toute porte à trois ou quatre entrées compte pour une seule ; une bibliothèque physique ou un FPGA peut implanter la fonction autrement.

MUX 4 vers 1 avec table de fonction et règle de dimensionnement. $n$ lignes de sélection choisissent parmi $2^n$ entrées.

Construire un MUX 4 vers 1 sur digisim.io

Suivez ces étapes pour construire un MUX 4 vers 1 à partir de portes distinctes :

1. Placez les lignes de sélection. Faites glisser deux composants INPUT_SWITCH sur la zone de travail et nommez-les $S_1$ et $S_0$.
2. Produisez les compléments. Placez deux portes NON. Reliez $S_1$ à l’une et $S_0$ à l’autre afin d’obtenir $\overline{S_1}$ et $\overline{S_0}$.
3. Placez les entrées de données. Ajoutez quatre composants INPUT_SWITCH et nommez-les $D_0$, $D_1$, $D_2$ et $D_3$.
4. Créez le réseau ET. Placez quatre portes ET à trois entrées :
   • ET-0 : ses entrées sont $\overline{S_1}$, $\overline{S_0}$ et $D_0$ ;
   • ET-1 : ses entrées sont $\overline{S_1}$, $S_0$ et $D_1$ ;
   • ET-2 : ses entrées sont $S_1$, $\overline{S_0}$ et $D_2$ ;
   • ET-3 : ses entrées sont $S_1$, $S_0$ et $D_3$.
5. Réunissez les résultats. Placez une porte OU et reliez-y les quatre sorties ET. Sa sortie est votre sortie finale $Y$.
6. Ajoutez une visualisation. Reliez $Y$ à un composant OUTPUT_LIGHT.

Basculez les sélecteurs afin d’acheminer différentes entrées de données vers la sortie. Dans un état de sélection valide et stable, un seul terme produit est activé ; sa valeur de données détermine Y.

Mettre des MUX en cascade : construire un 8 vers 1 avec des unités 4 vers 1

L’une des propriétés les plus utiles des multiplexeurs est leur possibilité d’être mis en cascade pour traiter davantage d’entrées. Il n’est pas nécessaire de concevoir un MUX 8 vers 1 de zéro : vous pouvez le construire à partir d’unités plus petites.

Un MUX 8 vers 1 nécessite trois lignes de sélection ($S_2$, $S_1$, $S_0$) et huit entrées de données ($D_0$ à $D_7$). Voici comment le réaliser avec deux MUX 4 vers 1 et un MUX 2 vers 1 :

1. Premier étage (deux MUX 4 vers 1) :
   • MUX-A traite $D_0$ à $D_3$, avec $S_1$ et $S_0$ comme lignes de sélection.
   • MUX-B traite $D_4$ à $D_7$, avec $S_1$ et $S_0$ comme lignes de sélection.
2. Second étage (un MUX 2 vers 1) :
   • La sortie de MUX-A est reliée à $D_0$ du MUX final.
   • La sortie de MUX-B est reliée à $D_1$ du MUX final.
   • $S_2$ sert de ligne de sélection à ce dernier MUX.

Lorsque $S_2 = 0$, le MUX final transmet le résultat de MUX-A (entrées $D_0$ à $D_3$). Lorsque $S_2 = 1$, il transmet celui de MUX-B (entrées $D_4$ à $D_7$). Les lignes de sélection de poids faible $S_1$ et $S_0$ choisissent laquelle des quatre entrées du groupe sélectionné atteint la sortie.

Cette approche hiérarchique s’étend à toute taille. Un MUX 16 vers 1 peut être construit avec deux MUX 8 vers 1 et un MUX 2 vers 1, ou avec quatre MUX 4 vers 1 alimentant un autre MUX 4 vers 1 au second niveau.

Un MUX 8 vers 1 avec trois lignes de sélection. Il peut être construit avec deux MUX 4 vers 1 et un MUX 2 vers 1.

Le MUX comme générateur universel de fonctions

Un MUX $2^n$ vers 1 peut réaliser n’importe quelle fonction booléenne de n variables en reliant ces variables aux lignes de sélection et les entrées de données aux constantes issues de la table de vérité. Le MUX est lui-même de la logique : il s’agit donc d’une réalisation structurelle, et non de logique obtenue « gratuitement ».

Prenons par exemple une fonction de trois variables $F(A, B, C)$. Avec un MUX 8 vers 1 :

1. Reliez $A$, $B$ et $C$ aux lignes de sélection $S_2$, $S_1$ et $S_0$.
2. Pour chaque ligne de la table de vérité, la combinaison de sélection adresse une entrée de données. Reliez cette entrée à 1 si $F=1$ pour la ligne correspondante, ou à 0 si $F=0$.

La sortie du MUX reproduit alors la table de vérité. Les tables de correspondance des FPGA utilisent des bits de configuration mémorisés et des circuits de sélection pour offrir la même capacité observable : toute fonction compatible avec le nombre d’entrées de la LUT. Leur structure interne et leurs ressources dédiées de mise en cascade sont propres à chaque famille de composants.

Vous pouvez également employer un MUX plus petit en appliquant une variable d’entrée aux lignes de données plutôt qu’aux lignes de sélection. Une fonction à trois variables peut ainsi être réalisée avec un MUX 4 vers 1 — et seulement deux lignes de sélection — en reliant $A$ et $B$ aux lignes de sélection et chaque entrée de données à 0, 1, $C$ ou $\overline{C}$ selon le besoin.

Exemple détaillé : réalisation d’une fonction majorité

La fonction majorité à trois entrées produit 1 lorsque deux entrées ou plus valent 1. Sa table de vérité est :

Avec un MUX 8 vers 1 : reliez $A$, $B$, $C$ à $S_2$, $S_1$, $S_0$. Câblez les entrées de données $D_0$ à $D_7$ selon la colonne F : $D_0=0$, $D_1=0$, $D_2=0$, $D_3=1$, $D_4=0$, $D_5=1$, $D_6=1$, $D_7=1$. Aucune porte externe chargée de la fonction de données n’est nécessaire en dehors du MUX et des sources constantes.

Avec un MUX 4 vers 1 (forme réduite) : reliez $A$ et $B$ à $S_1$ et $S_0$. Regroupez les lignes de la table de vérité selon $AB$ :

• $AB=00$ : $F=0$ à la fois pour $C=0$ et $C=1$. Reliez $D_0 = 0$.
• $AB=01$ : $F=0$ lorsque $C=0$, $F=1$ lorsque $C=1$. Reliez $D_1 = C$.
• $AB=10$ : $F=0$ lorsque $C=0$, $F=1$ lorsque $C=1$. Reliez $D_2 = C$.
• $AB=11$ : $F=1$ à la fois pour $C=0$ et $C=1$. Reliez $D_3 = 1$.

La même fonction est ainsi réalisée avec un MUX plus petit, $C$ étant directement relié à deux entrées de données.

Délai de propagation et considérations temporelles

Comme tout circuit combinatoire physique, un MUX possède un délai de propagation. Dans le schéma direct en somme de produits, une transition de sélection peut traverser un inverseur, un terme produit puis la réduction OU :

Ce n’est qu’une estimation topologique. Le délai réel dépend du choix des cellules, de la vitesse des fronts d’entrée, de la charge, du routage, de la tension, de la température et du fait que le chemin sélectionné parte d’une entrée de données ou de sélection. Les étages de sélection en cascade ajoutent des niveaux logiques, mais une large expression physique à un niveau peut aussi être lente en raison de la sortance et du câblage. Utilisez l’analyse temporelle du composant cible plutôt que de supposer qu’une topologie est deux fois plus rapide qu’une autre.

Les transitions de sélection peuvent aussi produire une brève impulsion à la sortie si les anciennes et nouvelles entrées de données diffèrent et que les chemins internes se stabilisent à des instants différents. Enregistrez le résultat lorsqu’il franchit une frontière synchrone, maintenez la sélection stable pendant l’intervalle requis et n’utilisez pas une sortie de MUX non qualifiée comme horloge ou impulsion d’écriture asynchrone. La simulation fonctionnelle valide la logique de sélection, mais peut ne pas modéliser les aléas ou délais physiques.

Expression booléenne générale d’un MUX $N$ vers 1

Nous pouvons généraliser l’expression booléenne du MUX à toute taille. Pour un MUX $2^n$ vers 1 avec les lignes de sélection $S_{n-1}, S_{n-2}, \ldots, S_0$ et les entrées de données $D_0, D_1, \ldots, D_{2^n - 1}$ :

$Y = \sum_{i=0}^{2^n - 1} \left( D_i \cdot m_i \right)$

où $m_i$ est le $i$-ième minterme des variables de sélection. Chaque minterme est le produit de toutes les variables de sélection, chacune apparaissant sous sa forme directe ou complémentée selon la représentation binaire de $i$. Par exemple, dans un MUX 8 vers 1, le minterme correspondant à $i=5$ (binaire 101) est $S_2 \cdot \overline{S_1} \cdot S_0$.

Cette formulation montre clairement qu’un MUX est littéralement une réalisation matérielle de la forme canonique en somme de mintermes. Toute fonction booléenne possède une expression unique en somme de mintermes, et un MUX peut la réaliser directement lorsque ses entrées de données sont reliées aux constantes appropriées.

L’entrée de validation

De nombreux circuits intégrés MUX du commerce comportent une broche de validation ou de stroboscope, souvent active au niveau bas. Le comportement désactivé dépend du composant : la sortie peut être forcée à zéro, forcée à un ou — dans une autre classe de composants — placée en haute impédance. Pour une validation abstraite E active au niveau haut et qui force Y à zéro lorsqu’elle est inactive :

$Y = E \cdot \left(\overline{S_1}\,\overline{S_0}\,D_0 + \overline{S_1}\,S_0\,D_1 + S_1\,\overline{S_0}\,D_2 + S_1\,S_0\,D_3\right)$

Une validation peut simplifier la mise en cascade et la qualification des commandes, mais n’est pas indispensable à toute hiérarchie de MUX. Il ne faut pas confondre la sortie en étage push-pull d’un MUX avec un pilote de bus trois états.

Lorsque vous construisez des MUX en cascade sur digisim.io, vous pouvez simuler la validation en ajoutant une porte ET entre la sortie OU finale et un interrupteur de validation.

Analogie concrète : le sélecteur d’entrée d’un téléviseur

Imaginez quatre sources vidéo — console de jeu, décodeur, lecteur Blu-ray et boîtier de diffusion — pour un seul téléviseur. Un MUX ressemble au sélecteur d’entrée : le bouton de la télécommande, c’est-à-dire les lignes de sélection, détermine la source qui apparaît à l’écran, la sortie. Les données vidéo circulent en permanence depuis les quatre sources, mais le MUX ne laisse passer vers l’écran que celle qui est sélectionnée.

Le sélecteur de chaîne comme MUX : les lignes de sélection choisissent la source d’entrée affichée sur le téléviseur.

Le démultiplexeur (DEMUX)

L’opposé d’un MUX est un démultiplexeur (DEMUX). Alors qu’un MUX sélectionne l’une de plusieurs entrées et l’achemine vers une sortie unique, un DEMUX prend une seule entrée et la dirige vers l’une de plusieurs sorties selon les lignes de sélection.

Les expressions booléennes d’un DEMUX 1 vers 4 sont :

$Y_0 = D \cdot \overline{S_1} \cdot \overline{S_0}$ $Y_1 = D \cdot \overline{S_1} \cdot S_0$ $Y_2 = D \cdot S_1 \cdot \overline{S_0}$ $Y_3 = D \cdot S_1 \cdot S_0$

Un DEMUX est structurellement identique à un décodeur muni d’une entrée de validation. Lorsque l’entrée de données $D$ joue ce rôle, l’« adresse » portée par les lignes de sélection détermine la sortie qui reçoit le signal.

Un DEMUX 1 vers 4 : une entrée est acheminée vers l’une de quatre sorties en fonction de deux lignes de sélection.

Applications des multiplexeurs

Les multiplexeurs apparaissent à tous les niveaux de la conception des systèmes numériques. Voici leurs applications les plus importantes, avec assez de détails pour comprendre pourquoi ils sont indispensables.

Fichier de registres du processeur

Dans une petite banque de registres construite à partir de bascules distinctes, chaque port de lecture asynchrone peut être modélisé comme un MUX de la largeur d’un mot, sélectionné par un indice de registre. Une banque pédagogique de huit registres de huit bits emploierait, pour chaque port de lecture, huit sélections de bit 8 vers 1 en parallèle. Les fichiers de registres physiques d’un ASIC ou d’un FPGA peuvent plutôt utiliser des macrocellules mémoire, des lignes de mot décodées, des lignes de bit, des ressources RAM dédiées ou de la logique distribuée. Le modèle à MUX décrit la sélection visible de l’extérieur, et non une topologie de transistors obligatoire.

Sélection des entrées de l’UAL

Les opérandes de l’UAL ne proviennent pas toujours des registres. Un opérande peut être une constante immédiate encodée dans l’instruction ou une valeur lue en mémoire. Un MUX placé à chaque entrée de l’UAL permet à l’unité de commande de choisir la source de l’opérande : sortie du fichier de registres, valeur immédiate ou registre de données mémoire. Ce seul MUX par entrée de l’UAL donne au processeur la souplesse nécessaire pour exécuter avec le même matériel des instructions registre-registre, registre-immédiat et mémoire-registre.

Décodage des adresses mémoire et arbitrage du bus

Lorsque plusieurs cibles peuvent renvoyer des données, un MUX sélectionne la réponse associée à une requête décodée. Lorsque plusieurs maîtres demandent une ressource, un arbitre choisit le propriétaire, puis des MUX d’acheminement transmettent l’adresse, les données et les commandes du maître sélectionné. Le MUX n’assure ni l’équité, ni le dialogue demande/accord ; il se contente d’acheminer selon le résultat de l’arbitrage.

Tables de correspondance des FPGA

Une primitive logique courante des FPGA est la table de correspondance (LUT). Un état de configuration mémorise les valeurs de la table de vérité, et les entrées logiques sélectionnent la valeur applicable. Une LUT conceptuelle à k entrées se comporte donc comme une table de vérité à $2^k$ entrées, sélectionnée par k signaux. Les familles de FPGA réelles emploient des circuits de LUT, des modes de fractionnement, des multiplexeurs dédiés à la cascade et un routage propres à leur architecture ; « un MUX 64 vers 1 » est donc un modèle fonctionnel utile plutôt qu’un schéma physique universel.

À vous de jouer

Construisez ces circuits dans l’éditeur de digisim.io pour consolider votre compréhension :

1. Construisez un MUX 2 vers 1 avec deux portes ET, une porte OU et une porte NON. Vérifiez les quatre combinaisons d’entrée.
2. Passez à un MUX 4 vers 1 grâce à l’expression booléenne ci-dessus. Sondez la sortie en parcourant des combinaisons de sélection stables.
3. Mettez en cascade deux MUX 4 vers 1 et un MUX 2 vers 1 afin de construire un 8 vers 1. Vérifiez que chacune des huit entrées peut être adressée séparément.
4. Réalisez une fonction booléenne avec un MUX. Choisissez une fonction quelconque de trois variables dans une table de vérité et programmez-la dans un MUX 8 vers 1 en câblant ses entrées de données à des constantes.
5. Construisez un DEMUX pour inverser l’acheminement : envoyez un signal vers l’une de quatre sorties.

Poursuivez avec les décodeurs et encodeurs, cousins structurels du DEMUX, découvrez comment les MUX alimentent l’UAL dans le cycle de chargement, décodage et exécution, ou ouvrez la référence du composant ET, brique principale de tout MUX.

Référence

• Documentation produit du sélecteur de données/multiplexeur 8 vers 1 SN74HC151 de Texas Instruments