Utiliser un multiplexeur analogique CD4051B avec une carte Arduino / Genuino

8 entrées / sorties analogiques pour le prix d'une seule

par skywodd | May 11, 2016 | Licence (voir pied de page)

Catégories : Tutoriels Arduino | Mots clefs : Arduino Genuino Analog Mux

Cet article n'a pas été mis à jour depuis un certain temps, son contenu n'est peut être plus d'actualité.

Dans ce tutoriel, nous parlerons d'un petit circuit intégré bien pratique : le CD4051B, un multiplexeur analogique. Nous verrons à quoi sert ce circuit intégré et comment l'utiliser. Si vous avez déjà rêvé d'aligner des dizaines de potentiomètres ou de boutons sur un même panneau de contrôle, cet article est fait pour vous !

Sommaire

• Le CD4051B
• Le montage de démonstration
• Le code
• Bonus : quelques idées d'utilisations peu conventionnelles
• Conclusion

Bonjour à toutes et à tous !

Une carte Arduino UNO dispose de 6 entrées analogiques, mais que faire si l'on veut câbler 8 potentiomètres ? Une solution simple serait d'utiliser une carte Arduino Mega2560 qui dispose de 16 entrées analogiques, mais cela pourrait être un peu disproportionné et couteux si le reste du circuit n'est pas très complexe.

Une bien meilleure solution quand on manque d'entrées analogiques (ou numérique), sans pour autant avoir besoin (ou envie) d'utiliser une carte plus "riche" en entrées / sorties, est d'utiliser un (dé)multiplexeur analogique. Dans cet article nous allons voir ensemble le fonctionnement d'un (dé)multiplexeur analogique 8 voies, le CD4051B.

N.B. Le circuit intégré CD4051B existe aussi en version 74HCxxxx sous la référence 74HC4051. C'est le même circuit intégré, seule la technologie utilisée pour le fabriquer est différente. Si vous ne savez pas quoi prendre, achetez un CD4051B.

Le CD4051B

Le circuit intégré CD4051B est un multiplexeur / démultiplexeur analogique huit voies bidirectionnelles.

Pour faire simple, il s'agit d'une série de huit interrupteurs contrôlés électroniquement et miniaturisés dans un même circuit intégré, avec d'un côté huit connexions indépendantes et de l'autre une connexion commune.

N.B Le CD4051B se comporte comme un interrupteur, dans les deux sens, cela signifie que l'on peut s'en servir pour connecter plusieurs capteurs à une même entrée analogique ou à l'inverse, connecter plusieurs actionneurs à une même sortie PWM par exemple. Attention, le signal n'est cependant transmis aux broches d'entrées / sorties que lorsque la voie adéquate est active. Si vous envoyez un signal PWM sur la voie n°0, en passant sur la voie n°1, le signal sur la voie n°0 s'arrêtera, comme avec un interrupteur classique.

PS Une seule voie est active à tout instant t. Il n'est pas possible d'avoir plusieurs voies actives en même temps.

PS Le CD4051B est conçu pour manipuler des signaux analogiques, mais rien n'empêche de l'utiliser avec des signaux numériques si besoin. C'est même un très bon outil pour connecter facilement un grand nombre de boutons poussoirs par exemple

Pour le câblage du CD4051B, on retrouve :

• une broche d'alimentation positive (VDD, de 3 à 20 volts maximum),

• une broche d'alimentation négative (VEE, optionnelle, uniquement si besoin de mesurer des signaux analogiques inférieurs à 0 volt, à relier à la masse sinon),

• une masse (VSS),

• huit broches d'entrées / sorties indépendantes sur lesquelles connecter ses capteurs / actionneurs,

• trois broches d'adresses pour sélectionner la voie à connecter (A, B, C),

• une broche d'activation (INH),

• une broche d'entrée / sortie commune sur laquelle connecter sa carte Arduino.

Le principe de fonctionnement du CD4051B est assez simple :

• On choisi la voie à activer en binaire avec les broches A, B et C,

• On met la broche INH à LOW (si ce n'est pas déjà fait),

• Et voilà !

Les broches d'adresses et la broche INH se comportent comme décrit ci-dessous (0 = LOW, 1 = HIGH, X = "peu importe") :

Si par exemple, on place les broches A, B, C à LOW, HIGH, LOW et INH à LOW, en quelques nanosecondes, la broche d'entrée / sortie n°2 se retrouve connectée à la broche commune.

N.B. La première voie porte le numéro 0 dans le tableau et dans les documentations constructeurs !

Le montage de démonstration

Pour démontrer l'utilité du CD4051B, je vous propose de faire un montage de démonstration simple, mais efficace.

Voilà le problème à résoudre : 8 potentiomètres, une seule entrée analogique. C'est le cas d'usage parfait pour un CD4051B.

Pour réaliser ce montage, il va falloir :

• Une carte Arduino UNO (et son câble USB),

• Un CD4051B ou 74HC4051,

• Huit potentiomètres de 10K ohms,

• Un condensateur de 100 nF (optionnel),

• Une plaque d'essai et une montagne de fils pour câbler le montage.

Pour faire ce circuit, il faut commencer par relier les broches INH, A, B et C respectivement aux broches D2, D3, D4 et D5 la carte Arduino.

On relie ensuite les broches VSS et VEE à la masse de la carte Arduino (GND) et la broche VDD à la broche 5V de la carte Arduino.

On continue en reliant la broche commune à la broche A0 de la carte Arduino.

N.B. Il est possible d'utiliser n'importe quelle broche numérique pour câbler A, B, C et INH. Le choix des broches D2, D3, D4 et D5 pour ce tutoriel est parfaitement arbitraire, libre à vous de choisir d'autres broches si vous le souhaitez. Vous pouvez aussi choisir d'utiliser une autre broche que la broche A0 de la carte Arduino pour la broche commune du CD4051B.

On achève ensuite le circuit en reliant chaque sortie de potentiomètre à une des voies du CD4051B et chaque potentiomètre aux broches GND et 5V de la carte Arduino.

PS Si vous le souhaitez, vous pouvez ajouter un condensateur de 100 nF entre les broches VDD et VSS du CD4051B pour améliorer sa résistance aux parasites en provenance de l'alimentation.

Le code

Le montage est prêt, passons au code !

Le code n'aura qu'un but : lire les huit potentiomètres du montage de démonstration et envoyer sur le port série les valeurs lues pour les afficher sur le PC via le moniteur série.

1
2
3
4
5
6
7
8

// Broches d'adresse
const byte PIN_ENABLE = 2
const byte PIN_ADDR_A = 3
const byte PIN_ADDR_B = 4
const byte PIN_ADDR_C = 5
 
// Broche de signal
const byte PIN_SIG = A0;

On commence le code comme d'habitude avec les classiques déclarations de broches, au moyen de diverses constantes, à raison d'une constante par broche.

PS Vous remarquerez que j'ai utilisé un préfixe commun PIN_ pour toutes les broches et un autre PIN_ADDR_ pour les broches d'adresses. Cela rend le code plus simple et agréable à lire

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

void setup(){
  
  // Place les broches d'adresse en sortie et à LOW
  pinMode(PIN_ADDR_A, OUTPUT);
  pinMode(PIN_ADDR_B, OUTPUT); 
  pinMode(PIN_ADDR_C, OUTPUT); 
  digitalWrite(PIN_ADDR_A, LOW);
  digitalWrite(PIN_ADDR_B, LOW);
  digitalWrite(PIN_ADDR_C, LOW);
  
  // Active le CD4051B
  pinMode(PIN_ENABLE, OUTPUT);
  digitalWrite(PIN_ENABLE, LOW);
 
  // Message de bienvenue
  Serial.begin(9600);
  Serial.println("Demonstration CD4051B");
}

On continue ensuite avec la fonction setup(), qui a trois missions :

• initialiser les broches d'adresse en sortie et à LOW,

• initialiser la broche INH en sortie et à LOW, pour activer le CD4051B,

• afficher un petit message de bienvenue.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

void loop(){
 
  // Pour chaque voie, on renvoie la valeur sur le port série
  for(byte i = 0; i < 8; i++){
    Serial.print("Voie ");
    Serial.print(i);
    Serial.print(" : ");
    Serial.println(readAnalogMux(i));
  }
  
  // Delai pour l'affichage
  delay(1000);
}

Vient ensuite la fonction loop(), qui se contente de passer en revue chaque voie du CD4051 via une boucle et de lire puis afficher la valeur de chaque voie.

Un délai d'une seconde vient terminer l'affichage et éviter que le moniteur série côté PC ne croule sous les lignes de texte.

Le code permettant de lire une voie du CD4051B est contenu dans la fonction readAnalogMux(), décrite juste après

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int readAnalogMux(byte channel) {
  
  // On sélectionne la voie
  digitalWrite(PIN_ADDR_A, bitRead(channel, 0));
  digitalWrite(PIN_ADDR_B, bitRead(channel, 1));
  digitalWrite(PIN_ADDR_C, bitRead(channel, 2));
 
  // On lit la valeur courante
  return analogRead(PIN_SIG);
}

La fonction readAnalogMux() ci-dessus permet de lire une voie du CD4051B. Le numéro de voie (entre 0 et 7) est passé en paramètre.

La fonction readAnalogMux() assigne d'abord les broches d'adresses en fonction du numéro de voie. Pour faire cela, j'utilise une petite astuce, la fonction bitRead() permet d'extraire la valeur d'un bit d'une valeur. La fonction bitRead() retourne la valeur 0 ou 1, ce qui correspond exactement aux valeurs de LOW et HIGH. Il suffit donc d'enchainer trois bitRead() et trois digitalWrite() et le tour est joué.

Une fois les broches d'adresses configurées, il ne reste plus qu'à lire la valeur sur la broche commune avec un appel à la fonction analogRead().

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

/**
 * Exemple de code pour le circuit intégré CD4051B.
 */

// Broches d'adresse
const byte PIN_ENABLE = 2;
const byte PIN_ADDR_A = 3;
const byte PIN_ADDR_B = 4;
const byte PIN_ADDR_C = 5;
 
// Broche de signal
const byte PIN_SIG = A0;
 
/** Fonction setup() */
void setup(){
  
  // Place les broches d'adresse en sortie et à LOW
  pinMode(PIN_ADDR_A, OUTPUT);
  pinMode(PIN_ADDR_B, OUTPUT); 
  pinMode(PIN_ADDR_C, OUTPUT); 
  digitalWrite(PIN_ADDR_A, LOW);
  digitalWrite(PIN_ADDR_B, LOW);
  digitalWrite(PIN_ADDR_C, LOW);
  
  // Active le CD4051B
  pinMode(PIN_ENABLE, OUTPUT);
  digitalWrite(PIN_ENABLE, LOW);
 
  // Message de bienvenue
  Serial.begin(9600);
  Serial.println("Demonstration CD4051B");
}
 
/** Fonction loop() */
void loop(){
 
  // Pour chaque voie on renvoie la valeur sur le port série
  for(byte i = 0; i < 8; i++){
    Serial.print("Voie ");
    Serial.print(i);
    Serial.print(" : ");
    Serial.println(readAnalogMux(i));
  }
  
  // Delai pour l'affichage
  delay(1000);
}
 
/** Fonction de lecture pour le CD4051B */
int readAnalogMux(byte channel) {
  
  // On sélectionne la voie
  digitalWrite(PIN_ADDR_A, bitRead(channel, 0));
  digitalWrite(PIN_ADDR_B, bitRead(channel, 1));
  digitalWrite(PIN_ADDR_C, bitRead(channel, 2));
 
  // On lit la valeur courante
  return analogRead(PIN_SIG);
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Voilà ce que donne le code ci-dessus dans le moniteur série :

Bonus : quelques idées d'utilisations peu conventionnelles

Le CD4051B est bidirectionnel et il fonctionne aussi bien avec des signaux analogiques et numériques.

Voici donc quelques idées d'utilisations peu conventionnelles en guise de bonus :

• connecter un port série vers plusieurs modules séries,

• transmettre un signal SPI vers plusieurs esclaves ne disposant pas de broche ENABLE,

• contrôler 8 servomoteurs simultanément (nécessite un timing précis),

• lire l'état de huit boutons ou d'un clavier matriciel.

Si vous avez d'autres idées d'utilisations peu conventionnelles, faites-le-moi savoir dans les commentaires

Conclusion

Ce tutoriel est désormais terminé.

Si ce tutoriel vous a plu, n'hésitez pas à le commenter sur le forum, à le diffuser sur les réseaux sociaux et à soutenir le site si cela vous fait plaisir.

Cliquez ici pour accéder aux commentaires de l'article.