Et pourtant, c'est plus compliqué, car l'afficheur n'a aucune électronique à bord. Il y a simplement autant d'entrées qu'il y a de segments (diodes électroluminescentes) et le module a une anode commune (ou une cathode commune dans certains cas). Par chiffre à afficher il y a donc 7 segments et éventuellement un point décimal.

Commande multiplexée

Pour un afficheur à 4 chiffre comme dans une horloge il fallait 4 + 7 sorties au processeur. Pour un processeur utilisé dans une horloge, cela ne posait aucun problème car le processeur ne devait pas faire grand chose d'autre. Mais dans notre situation (commande à partir d'un arduino) on voudrait utiliser le moins de pattes possibles.

Le multiplexage n'est plus utilisé actuellement car il produit des interférences radio. Comme chaque chiffre n'est éclairé qu'un quart du temps, il faut un courant plus important, de l'ordre de 50mA par segment, alors que pour une commande statique un courant de 10 à 20mA suffit amplement.

Image d'oscilloscope avec les trois sorties de l'arduino: La ligne d'horloge en jaune avec deux fois 8 impulsions par chiffre à afficher La ligne data qui transmet d'abord les données (4 bits BCD avec le MSB en premier) et puis l'adresse (position du chiffre) également en 4 bits avec une ligne haute. Nous écrivons un "5" en position 2 et 3 avec entre les deux une transmission de données mais sans adresse. L'impulsion strobe effectue le transfert du régistre sériel vers la sortie parallèle

Décodeur 7 segments CMOS 4543

Ces puces ont un grand avantage, c'est la fonction de mémoire: quand le broche latch est haute, les codes BCD sont continuellement transformés en code 7 segments, quand la broche est basse les codes BCD ne sont plus transformés et la sortie est figée. On peut donc aisément sélectionner un chiffre en mettant la broche latch haute, tandis que les lignes BCD sont communes à tous les chiffres.

En plus de l'entrée BCD et de la sortie 7 segments, la puce a encore d'autres entrée: une entrée blanking (1 = afficheur éteint), phase (1 = anode commune) et latch (1 = transfert in to out).

C'est déjà une amélioration, avec 4 lignes "adresse" (sélection de la position) et 4 lignes data (données BCD) on peut commander l'afficheur complet. Mais on utilise toujours 8 pattes du processeur, alors qu'il est possible de commander l'afficheur avec moins de broches.

Série vers parallèle CMOS 4094

Un signal d'horloge et de strobe est nécessaire, la puce n'a pas d'entrée RS-232 ou équivalente. Au lieu d'utiliser une seule sortie de l'arduino, il faut en utiliser 3, mais c'est quand même mieux que les 11 ou 8 broches des montages précédents.

Commande du point décimal
On peut éventuellement commander le point décimal avec un petit détour. Les chiffres sont normalement sélectionnés l'un après l'autres, mais il n'est pas nécessaire que cela se fasse continuellement. Il n'est nécessaire de transmettre un nouveau chiffre que si celui ci a été modifié, donc une fois par minute dans le cas d'une horloge. Après que les 4 chiffres aient été transmis, on sélectionne à nouveau le chiffre (et data) dont on veut afficher le point. Cela fait allumer le point correspondant grace au transistor de commande. Il faut prévoir un transistor et quelques résistances par point qu'il faut allumer (auto range). S'il faut un point fixe, on peut l'allumer via une résistance vers la masse.

Transmettre le BCD deux fois
Le code pour un chiffre doit être transmis deux fois, une fois avec le code et l'adresse, une seconde fois avec uniquement le code et l'adresse à zéro. Aucune position n'est sélectionnée, mais les données sont encore valables. Si on ne fait qu'une seule transmission, on risque de faire apparaitre des chiffres non-valables: quand la ligne d'adresse va à zéro, les lignes de données changent simultanément (chiffre à la position suivante). Le circuit montre alors soit l'ancien chiffre, soit le nouveau chiffre, soit un chiffre indéfini.

La puce a encore une entrée supplémentaire, un output enable (si 1) et deux sorties sérielles pour connecter plusieurs modules à la chaine.

Décodeur BCD vers décimal CMOS 4028

La puce est placée en sortie du 4096 et avant la patte de sélection du 4543. Cette possibilité n'est pas reprise en détail sur le schéma. Attention, certaines versions de la puce ne mettent pas toutes les sorties à zéro quand on entre un code illégal (bcd > 10), il s'agit par exemple d'un CD4028CN.

Le 4028 est également utilisé dans la commande d'une horloge avec afficheurs nixie pour la sélection d'une position.

L'afficheur peut être éteint via l'entrée blanking du 4543, par l'envoi d'un chiffre illégal (11 à 15) ou en coupant l'alimentation 5V de l'afficheur. L'envoi d'un chiffre illégal permet d'éteindre un chiffre non significatif. Modifier la tension d'alimentation de l'afficheur permet également de modifier l'intensité, mais lde 4543 n'est conçu pour fournir que 5mA.

#define CLOCK 2
#define DATA 3
#define STROBE 4

void setup() {
  pinMode(CLOCK, OUTPUT);  pinMode(DATA, OUTPUT);  pinMode(STROBE, OUTPUT);
}

void seriel(byte x)  {            // seriel transmet un byte
static byte i, k;                 // contenant une adresse
  k = x;                          // et une donnée BCD
  for (i = 0; i < 8; i++) {       // send each bit
    // begin with first bit = most significant
    if (i == 4) {                 // séparer data de addr. sur l'oscilloscope
      digitalWrite(DATA, 0);          delay(1);
    }
    digitalWrite(DATA, k > 127);      delay(1);
    k = k << 1;                   // shift 1 bit left = *2
    digitalWrite(CLOCK, 1);           delay(1);
    // accept data sur flanc positif
    digitalWrite(CLOCK, 0);           delay(1);
  }
  digitalWrite(DATA, 0);              delay(1);
  // pas vraiment nécessaire mais c'est plus beau sur l'oscilloscope
  digitalWrite(STROBE, 1);            delay(1);
  // transfer serial data to parallel out byte complet
  digitalWrite(STROBE, 0);            delay(1);
}

  
void loop() {
static byte i, y, t[4], ot[4];
static int cnt, z;
static long ms, oms;
bool s = false;                 // pas static! doit être remis à 0
  z = analogRead(AIN);          // à chaque boucle
  y = 128;

  for (i = 0; i < 4; i++) {     // mettre chiffre à chaque position
    t[i] = z % 10;              // dans un tableau
    z = z / 10;
  }

  for (i = 3; i != 255; i--)  {   // envoi du tableau en sériel
    if (t[i] != 0)      s = true; // si le chiffre n'est pas 0,
                                  // il est significatif
    if (!s && i != 0)   t[i] = 11; // si non-signif. et non dernière pos
                                  // on efface le chiffre
    if (ot[i] != t[i]) {          // si le chiffre a changé,
      seriel (t[i] + y);          // on transmet: data + address
      seriel (t[i]);              // puis data sans address pour figer
      ot[i] = t[i];               // nouveau chiffre --> ancien chiffre
    }
    y = y >> 1;                   // bit suivant de l'adresse (shift right)
  }
}

void seriel(byte x)	{
	shiftOut(DATA, CLOCK, MSBFIRST, x);    // Most Significant bit first
	digitalWrite(STROBE, 1);	              // L'inverse est LSBFIRST
	delayMicroseconds(10);
	digitalWrite(STROBE, 0);            
}

Le points qui clignotent c'est l'indication de la position qui est modifiée. Il ne s'agit pas d'une indication de l'heure, mais d'un niveau.