9 Mai 2014

Arduino leçon 15 : le multiplexage

Qu'est-ce que le multiplexage ?

C'est un ensemble de techniques permettant de faire circuler différentes informations par les mêmes conducteurs. L'exemple le plus connu est le central téléphonique qui permet d'envoyer des milliers de conversations sur le même cable.
Le principe est d'envoyer chaque information pendant une toute petite fraction du temps.

Application aux afficheurs

Nous allons faire passer par les mêmes sorties d'Arduino les valeurs correspondant à 2 afficheurs, décalées dans le temps.
Quand on affichera le chiffre des dizaines, on éteindra l'afficheur des unités et vice versa et on le fera suffisemment vite pour que notre oeil ait l'impression que les 2 sont allumés en permanence.

Pour éteindre un afficheur à anode commune, il suffit de couper le courant qui arrive à l'anode.
Comme l'anode alimente tous les segments, on ne la branche pas directement sur une sortie d'arduino. On utilise un transistor en commutation pour chaque afficheur.

Le montage

On utilise un seul décodeur 7447 dont les sorties sont reliées aux 2 afficheurs.
On relie la sortie 11 d'Arduino à la base d'un transistors qui alimente l'anode commune du 1er afficheur.
idem pour la sortie 12 et le second afficheur.

Le programme

Il reçoit un nombre de 2 chiffres par le moniteur série.
Il envoie le courant sur l'anode du 1er afficheur.
Il envoie au décodeur les bits de poids nécessaires à l'écriture du 1er chiffre
Il le laisse 10 ms. Ce temps est nécessaire aux circuits. (essayer 5, qui suffit pour certains cicuits)
Il "éteint" l'afficheur.
Il fait ensuite la même chose pour le second afficheur.

PENDANT LES ESSAI, ON POURRA ATTENDRE 1 seconde AU LIEU DE 5 ou 10 ms

/*         multiplexage.ino                     fonctionnement de 2 afficheurs 7 segments           */           int i, toto, uni, diz, recu[20];           const byte poids1 = 2;           const byte poids2 = 3;           const byte poids4 = 4;           const byte poids8 = 5;                     void setup()       {                 pinMode(2, OUTPUT);                 pinMode(3, OUTPUT);                 pinMode(4, OUTPUT);                 pinMode(5, OUTPUT);                 pinMode(11, OUTPUT);                 pinMode(12, OUTPUT);                 Serial.begin(9600);                 Serial.println("Bonjour");                 Serial.println("Entrez un nombre de 2 chiffres.");                 }                         void loop()       {                 i = 0 ;                 while ( Serial.available() > 0 ) {                       toto = Serial.read();                       if ((toto>48) && (toto<58)) { // si on a un chiffre                             recu[i] = toto - 48 ;                             Serial.print(recu[i]);                             i++;                             delay(10);                       }                 }                 switch(i){                       case 0 : // pas de chiffre                             break;                       case 1 : // un seul chiffre                             diz = 0;                             uni = recu[0];                             Serial.println();                             break;                       case 2 : // on a reçu 2 chiffres                             uni = recu[1];                             diz = recu[0];                             Serial.println();                             break;                       default : // on a reçu plus de 2 chiffres                                   uni = 0;                             diz = 0;                             Serial.println(" 2 chiffres seulement, abruti !");                             digitalWrite(12, HIGH);                             digitalWrite(11, HIGH);                 }                 afficher ( 1, diz);                 afficher ( 2, uni);           }                     void afficher ( byte chip, byte chiffre )      {                 // ce sous-programme reçoit 2 paramètres :                 // - le N° de l'afficheur et                 // - le chiffre à afficher                 byte pin = chip + 10; // pin 11 ou 12 pour afficheur 1 ou 2                                       // on éteins les segments                 digitalWrite(poids1, LOW);                 digitalWrite(poids2, LOW);                 digitalWrite(poids4, LOW);                 digitalWrite(poids8, LOW);                                 digitalWrite(pin, HIGH);                                 switch (chiffre) {                 case 0 :                             break;                 case 1 :                             digitalWrite(poids1, HIGH);                             break;                 case 2 :                             digitalWrite(poids2, HIGH);                             break;                 case 3 :                             digitalWrite(poids1, HIGH);                             digitalWrite(poids2, HIGH);                             break;                 case 4 :                             digitalWrite(poids4, HIGH);                             break;                 case 5 :                             digitalWrite(poids1, HIGH);                             digitalWrite(poids4, HIGH);                             break;                 case 6 :                             digitalWrite(poids2, HIGH);                             digitalWrite(poids4, HIGH);                             break;                 case 7 :                             digitalWrite(poids1, HIGH);                             digitalWrite(poids2, HIGH);                             digitalWrite(poids4, HIGH);                             break;                 case 8 :                             digitalWrite(poids8, HIGH);                             break;                 case 9 :                             digitalWrite(poids1, HIGH);                             digitalWrite(poids8, HIGH);                             break;                 }                 delay(1000);             //       5 ou 10 après la mise au point                 digitalWrite(pin, LOW);           }

Multiplexage pour afficheur à 4 chiffres

8 Avril 2016

Pour notre exemple, on choisit le nombre 2016.
Quand on affiche un chiffre, on éteint les autres. On alterne très vite pour que notre oeil ait l'impression que les quatre sont allumés en permanence.
Pour éteindre un chiffre, on supprime l'alimentation de son anode.
Chaque sortie d'Arduino n'a pas la puissance nécessaire pour piloter les anodes de 7 segments à la fois. On passe par des transistors.
On relie la base d'un transistor NPN à chacune des pins 6 à 9 d'Arduino.
Les émetteurs sont reliés aux anodes des afficheurs et aussi à la masse par une résistance de très grande valeur.
Les collecteurs sont reliés à VCC

L'afficheur à 4 chiffres

Cet afficheur à anode commune à 4 chiffre possède 2 rangées de 6 pattes. Voici son schéma de branchement.

Vous voyez par exemple que la borne 1 commande les segments "e" de tous les chiffres et que la borne 12 commande l'anode du premier chiffre.

Le montage

Le programme :

/*                     aff_7seg_2016.ino                           affiche le nombre 2016 sur un quadruple afficheur                           les broches 2 à 5 sont reliées au 7447                           les broches 6 à 9 sont reliées aux anodes via des transistors.                     */                     const byte poids1 = 2;           const byte poids2 = 3;           const byte poids4 = 4;           const byte poids8 = 5;                     void setup()       {                 pinMode(2, OUTPUT);                 pinMode(3, OUTPUT);                 pinMode(4, OUTPUT);                 pinMode(5, OUTPUT);                 pinMode(6, OUTPUT);                 pinMode(7, OUTPUT);                 pinMode(8, OUTPUT);                 pinMode(9, OUTPUT);                 }                         void loop()       {                 afficher( 9, 2 );                 afficher( 8, 0 );                 afficher( 7, 1 );                 afficher( 6, 6 );                 }           void afficher ( byte pin, byte chiffre )      {                 // ce sous-programme reçoit 2 paramètres :                 // - la broche qui commande l'anode de l'afficheur                 // - le chiffre à afficher                                 // on éteint les segments                 digitalWrite(poids1, LOW);                 digitalWrite(poids2, LOW);                 digitalWrite(poids4, LOW);                 digitalWrite(poids8, LOW);                 // on valide l'afficheur                 // on sélectionne les segments à allumer                 switch (chiffre) {                 case 0 :                             break;                 case 1 :                             digitalWrite(poids1, HIGH);                             break;                 case 2 :                             digitalWrite(poids2, HIGH);                             break;                 case 6 :                             digitalWrite(poids2, HIGH);                             digitalWrite(poids4, HIGH);                             break;                 }                 digitalWrite(pin, HIGH);       // on valide l'afficheur ( 5 volts sur l'anode)                 delay(1000);       // on changera cette valeur après la mise au point                 digitalWrite(pin, LOW);       // on invalide l'afficheur           }

haut de la page
Page Précédente : les afficheurs 7 segments           Page Suivante : révisions