Indicateur 7 segments leds
Commande à partir d'un arduino
TechTalk
Root » Serveurs » Electro-ménager » Electronique » Commande d'un indicateur 7 segments leds à partir d'un arduino

S'il est possible de commander un écran LCD ou une série de tubes nixie à partir d'un arduino, cela ne devrait pas être trop compliqué de commander un afficheur à 7 segments leds...
-

-

La commande d'un écran LCD s'effectue avec le protocole série TTL (il ne faut donc même pas de conversiuon de niveaux). Il ne devrait donc pas être trop difficile de commander un afficheur à 7 segments.

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

Quand les afficheurs sont apparus, ils étaient souvent commandés en multiplex. Pour commander 4 chiffres, il fallait 4 transistors PNP pour fournir le courant anodique des diodes. Les segments du chiffre recevaient un courant via 7 transistors NPN car les processeurs de l'époque ne pouvaient fournir qu'un faible courant de quelques milliampère. Après la commande d'un chiffre, le processeur passait au chiffre suivant et ainsi de suite.

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

Les décodeurs 7 segments transforment un code BCD (binary coded decimal) en commande d'afficheur 7 segments. Ces décodeurs fonctionnent aussi bien avec les afficheurs à anode commune que cathode commune et peuvent même commander des afficheurs à cristaux liquides si on met une tension alternative sur une des broches. La fonction est disponible sous différents codes: 4054, 4543, 4558,...

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

La famille CMOS a beaucoup de membres interessants, comme un transfert sériel vers parallèle. Les 8 bits sériels sont lus lors du flanc ascendant du signal d'horloge et les 8 bits sont disponibles sur la sortie parallèle après une impulsion strobe.

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


Il est facile de commander jusqu'à 10 chiffres sans devoir utiliser de ligne de processeur supplémentaire: nous avons en effet un bus d'adresse qui n'a qu'une seule ligne haute à un moment donné. Avec un décodeur BCD vers décimal on peut commander 10 chiffres (et éventuellement le point décimal correspondant). Le code data sans adresse pour figer le chiffre qui vient d'être modifié (flanc descendant de la ligne de sélection) est transmis via un code BCD illégal, par exemple 15.

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)
  }
}
Arduino dispose d'une instruction pour envoyer automatiquement les données sous forme sérielle, c'est l'instruction shiftOut(). Voici la routine seriel utilisant cette instruction. Son utilisation est toute simple, mais ne permet pas de séparer dans le temps les deux nibbles.

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.

Links to relevant pages - Liens vers d'autres pages au contenu similaire - Links naar gelijkaardige pagina's

-