Utiliser un multiplexeur analogique CD4067B avec une carte Arduino / Genuino

Quoi de mieux que 8 entrées / sorties analogiques ? 16 !

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

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

Cet article a été modifié pour la dernière fois le May 17, 2016 at 11:45 a.m.

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

Dans un précédent tutoriel, nous avions parlé d'un multiplexeur analogique 8 voies. Dans ce tutoriel, nous parlerons d'un autre multiplexeur analogique, à 16 voies cette fois-ci : le CD4067B. Nous verrons à quoi sert ce circuit intégré et comment l'utiliser.

Sommaire

• Le CD4067B
• Le montage de démonstration
• Le code
• Conclusion

Bonjour à toutes et à tous !

Dans mon précédent article, nous avions parlé d'un multiplexeur analogique à 8 voies. Cependant, 8 voies n'est parfois toujours pas suffisant, c'est pourquoi aujourd'hui on va parler du grand frère du CD4051B : le CD4067B, un multiplexeur analogique à 16 voies. Avec autant d'entrées / sorties analogiques à porter de code, toutes les folies sont permises

N.B. Le circuit intégré CD4067B existe aussi en version 74HCxxxx sous la référence 74HC4067. 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 CD4067B.

Le CD4067B

Le circuit intégré CD4067B est un multiplexeur / démultiplexeur analogique seize voies bidirectionnel. Avec seize voies on peut facilement envisager de construire des panneaux de contrôle ou des circuits relativement complexes.

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

N.B Le CD4067B 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ête, 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 CD4067B 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 CD4067B, on retrouve :

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

• une masse (VSS),

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

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

• une broche d'activation (INH),

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

Le principe de fonctionnement du CD4067B est assez simple :

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

• 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, D à LOW, HIGH, LOW, LOW et INH à LOW, en quelques nanosecondes, la broche d'entrée / sortie n°4 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 CD4067B, je vous propose de faire un montage de démonstration simple, mais efficace.

Voilà le problème à résoudre : 16 potentiomètres, une seule entrée analogique. C'est le cas d'usage parfait pour un CD4067B et le pire cauchemar du bricoleur sur plaque d'essai (vous comprendrez vite pourquoi en regardant les photos du montage).

Pour réaliser ce montage, il va falloir :

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

• Un CD4067B ou 74HC4067,

• Seize potentiomètres de 10K ohms,

• Un condensateur de 100nF (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, C et D respectivement aux broches D2, D3, D4, D5 et D6 de la carte Arduino.

On relie ensuite les broches VSS à 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 quelles broches numériques pour câbler A, B, C, D et INH . Le choix des broches D2, D3, D4, D5 et D6 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 CD4067B.

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

PS Si vous le souhaitez, vous pouvez ajouter un condensateur de 100nF entre les broches VDD et VSS du CD4067B 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 seize 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
9

// 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;
const byte PIN_ADDR_D = 6;
 
// 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
19
20

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); 
  pinMode(PIN_ADDR_D, OUTPUT); 
  digitalWrite(PIN_ADDR_A, LOW);
  digitalWrite(PIN_ADDR_B, LOW);
  digitalWrite(PIN_ADDR_C, LOW);
  digitalWrite(PIN_ADDR_D, LOW);
  
  // Active le CD4067B
  pinMode(PIN_ENABLE, OUTPUT);
  digitalWrite(PIN_ENABLE, LOW);
 
  // Message de bienvenue
  Serial.begin(9600);
  Serial.println("Demonstration CD4067B");
}

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 CD4067B,

• 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 < 16; 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 CD4067 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 textes.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

La fonction readAnalogMux() ci-dessus permet de lire une voie du CD4067B. Le numéro de voie (entre 0 et 15) 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 quatre bitRead() et quatre 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
60
61
62
63

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

// 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;
const byte PIN_ADDR_D = 6;
 
// 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); 
  pinMode(PIN_ADDR_D, OUTPUT); 
  digitalWrite(PIN_ADDR_A, LOW);
  digitalWrite(PIN_ADDR_B, LOW);
  digitalWrite(PIN_ADDR_C, LOW);
  digitalWrite(PIN_ADDR_D, LOW);
  
  // Active le CD4067B
  pinMode(PIN_ENABLE, OUTPUT);
  digitalWrite(PIN_ENABLE, LOW);
 
  // Message de bienvenue
  Serial.begin(9600);
  Serial.println("Demonstration CD4067B");
}
 
/** Fonction loop() */
void loop(){
 
  // Pour chaque voie on renvoie la valeur sur le port série
  for(byte i = 0; i < 16; i++){
    Serial.print("Voie ");
    Serial.print(i);
    Serial.print(" : ");
    Serial.println(readAnalogMux(i));
  }
  
  // Delai pour l'affichage
  delay(1000);
}
 
/** Fonction de lecture pour le CD4067B */
int readAnalogMux(byte channel) {
  
  // On selectionne la voie
  digitalWrite(PIN_ADDR_A, bitRead(channel, 0));
  digitalWrite(PIN_ADDR_B, bitRead(channel, 1));
  digitalWrite(PIN_ADDR_C, bitRead(channel, 2));
  digitalWrite(PIN_ADDR_D, bitRead(channel, 3));
 
  // 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 :

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.