Electronique > Réalisations > Affichage / Mesures > Journal lumineux 002

Dernière mise à jour : 19/07/2015

Présentation

Cette réalisation permet d'afficher un message sur un bandeau de 50 ou 80 colonnes de 7 LED câblées en matrice (10 matrices 5x7 ou 8x8).

journal_lumineux_002c_proto_001a journal_lumineux_002b_proto_jmk_001b

Le circuit met en oeuvre un PIC 18F46K22 et peut afficher jusqu'à 10 caractères en simultané, chaque caractère occupant 5 colonnes et 7 rangées (5x7). L'affichage est de type multiplexé, toutes les LED ne sont pas allumées en même temps. Pour ce circuit, on peut utiliser des LED individuelles ou des matrices de LED 5x7 ou 8x8 (pour ces dernières, les 8 LED du bas restent éteintes). J'ai travaillé sur trois schémas :
- schéma 002(a) : avec registres à décalage 74595 et matrices LED 5x7
- schéma 002b : avec drivers de LED MAX7219 et matrices LED 5x7
- schéma 002c : avec drivers de LED MAX7219 et matrices LED 8x8
Avec le montage 002(a), le multiplexage d'affichage est effectué par le PIC, alors que dans les montages 002b et 002c, le multiplexage d'affichage est effectué par les MAX7219.

Caractéristiques principales

Les caractéristiques indiquées ci-après sont valables pour les versions 002(a), 002b et 002c. Pour l'instant, seules les versions 002b et 002c ont été testées en grandeur réelle (maquette physique).Nota 1 : le logiciel peut être adapté pour mémoriser des messages plus longs mais en moins grand nombre, par exemple 120 messages de 64 caractères ou 60 messages de 128 caractères. En installant 8 mémoires externes de 64 K au lieu d'une seule, on pourrait traiter 2000 messages de 32 caractères ou 250 messages de 255 caractères. A l'heure actuelle j'utilise une 24FC512 qui reste sous-exploitée.

Schéma 002(a)

Dans le principe, le fonctionnement est simple puisqu'il consiste à afficher les 50 colonnes de LED les unes après les autres.

journal_lumineux_002

Mais dès qu'on veut passer à la pratique, on s'amuse un peu plus (ou un peu moins, selon le sens de la pile).

Affichage des caractères
La méthode utilisée pour afficher les caractères colonne par colonne est décrite à la page Multiplexage d'affichage. Tous les caractères à afficher sont stockés sous formes de colonnes (5 colonnes de 7 points) et une seule colonne est affichée à un instant donné. Comme il y a 50 colonnes, cela signifie que la luminosité globale n'est pas des plus élevées, puisque chaque colonne est allumée 1/50 du temps. Cela ne pose pas de problème si les afficheurs sont "très" lumineux. Les colonnes sont activées par les sorties des registres à décalage 74(HCT)595, tandis que les 7 points de chaque colonne sont activés par des transistors darlington intégrés dans un ULN2803. Ce choix impose l'utilisation d'afficheurs de type "Cathodes sur rangées et anodes sur colonnes". Le transfert des caractères se fait en appliquant un niveau haut permanent sur l'entrée Data du premier registre à décalage et en injectant un signal rectangulaire sur l'entrée Horloge (Clk, Clock) de tous les registres. Vu le principe adopté ici, on pourrait assimiler le groupe de registre à un compteur Johnson doté de 56 sorties. D'ailleurs, de simples CD4017 pourraient tout aussi bien faire l'affaire, leur seul "défaut" serait de ne pas pouvoir débiter assez de courant, ce qui conduirait à une luminosité plus faible. A chaque fois que le logiciel a effectué un cycle complet d'affichage (50 pas d'affichage colonne) les registres à décalage sont remis à zéro. Cela n'est absolument pas obligatoire, il s'agit d'une simple précaution qui nécessite peu de temps processeur et évite de mauvaises surprises en cas de "dérapage" d'un des registres. La matrice de LED rouge visible sur le schéma montre juste qu'on peut piloter 11 matrices 5x7 avec 7 registres 74595 (7 x 8 = 56 sorties). La fréquence de rafraichissement est de 1500 Hz, soit 30 Hz par colonne. Ce mode de fonctionnement présente l'intérêt de faire appel à des composants standards pour la section affichage, ce qui le rend économique à réaliser. Mais le revers de la médaille est que l'affichage est moins lumineux et que les ressources demandées au microcontrôleur sont plus grandes (l'affichage se fige durant les modifications de texte, pas très critique mais moins "pro").

Réglage vitesse et luminosité
Ces deux paramètres peuvent être modifiés au moyen des touches SW9 à SW12.

Consommation électrique
Si on exclue la consommation propre du PIC qui est de quelques mA, la consommation se limite au maximum à l'allumage de 7 LED. En optant pour un courant de 20 mA par LED, cela nous fait au maximum 140 mA, ce qui est très raisonnable !

Multiplexage clavier à touches (boutons-poussoirs)
Les touches sont câblées de façon multiplexées pour (là encore) économiser sur le nombre de lignes d'entrée/sortie. Des diodes sont câblées en série avec chaque interrupteur pour éviter tout disfonctionnement ou dommage matériel en cas d'appui simultané sur deux boutons-poussoirs. Ces diodes peuvent bien sûr être ajoutées pour les autres versions (002b et 002c). Elles restent facultatives car on peut faire attention à ne toujours presser qu'un seul bouton à la fois. Mais même moi qui faisais pourtant attention, j'ai grillé une ligne d'entrée/sortie de mon dernier PIC suite à fausse manoeuvre.

Schéma 002c - MAX7219 et matrices LED 8x8

Dans ce schéma, le PIC envoie les données à afficher à des MAX7219, et ces derniers se chargent du multiplexage.

journal_lumineux_002c

Je préfère parler du schéma 002c avant de parler du 002b, car il me semble plus logique d'utiliser au maximum les possibilités d'affichage, que je "réduirai" ensuite. Chaque MAX7219 pilote une matrice de 8x8 LED, toutes les broches sont utilisées. La mise à jour du journal complet demande 10 ms, j'aurais pu faire plus court (le MAX7219 accepte des signaux cadencés à 10 MHz) mais je n'en voyais pas l'utilité ici.

Principe de fonctionnement
Il diffère de celui adopté pour le schéma 002(a) puisqu'ici ce sont les circuits intégrés MAX7219 qui assurent la fonction de multiplexage. Le traitement des données que le PIC doit envoyer est un peu moins simple mais pas insurmontable. Il faut juste savoir comment chaîner les MAX7219 puisqu'ils ne disposent pas d'adresse permettant de les solliciter de manière individuelle. Ils se comportent en fait comme de simples registres à décalage, leur particularité réside juste dans le traitement de données sous forme de deux octets : un premier qui indique quoi faire (commande) et un second qui indique la valeur. Un des intérêts de ce type de circuit est d'effectuer en local la fonction de multiplexage, ce qui décharge le processeur (ou microcontrôleur) d'une bonne charge de travail. Il est également possible d'indiquer le taux de luminosité par commandes logicielles, je ne me suis pas privé de cette option. Pour le défilement du texte, les interruptions du Timer0 (période 25 ms, soit 40 Hz) sont mises à contribution. Un clavier à touches permet de sélectionner le message à afficher, d'en modifier le contenu et d'ajuster le taux de luminosité. Le module UART1 du PIC permet de programmer les textes à afficher de façon simple et rapide, au moyen d'un ordinateur équipé d'un émulateur de terminal.

Réglage vitesse et luminosité
Ces deux paramètres peuvent être modifiés au moyen des potentiomètres RV1 et RV2.

Consommation électrique
Dans cette configuration, le système peut consommer une intensité de courant assez élevée. Le multiplexage porte sur des groupes de 8 colonnes, ce qui veut dire qu'à un instant donné on peut avoir 10 colonnes pleines (7 LED allumées). Si le courant réglé pour chaque LED est de 20 mA, cela conduit à une consommation instantanée ou de pointe de :
iMax = 10 * 7 * 0,02 A = 1,4 A
Ah oui, tout de même ! Qu'à cela ne tienne, on va réduire cette monstrueuse valeur en jouant sur deux paramètres :
Avec un rapport cyclique PWM de 50% (et en tenant compte du rapport existant de 1/8 du temps, ce qui donne 1/16 du temps) et un courant de LED de 10 mA, on réduit la consommation moyenne par quatre et on peut dans ce cas se contenter d'une alim capable de débiter 350 mA. Bien sûr, une petite marge ne fera pas de mal, je suggère une alim de 500 mA. Si vous voulez pouvoir ajuster la luminosité au max (toujours pour 10 mA par LED), il faudra dans ce cas une alim de 750 mA (je conseille 1 A). Un découplage d'alimentation individuel doit être prévu pour le PIC et pour chacun des dix circuits de commande LED MAX7219, voir suggestion suivante :

journal_lumineux_002c_ps_cap

Les résistances seront idéalement de valeur comprise entre 0,1 ohm et 1 ohm (puissance 1/4 W). Elles pourront être supprimées si les fils qui amènent l'alimentation aux MAX7219 sont longs et fins (ce que je ne conseille pas en particulier).

Sélection/affichage d'un message existant
Deux possibilités sont offertes pour sélectionner l'affichage du texte désiré parmi les 200 textes possibles :
- soit en pressant sur les boutons-poussoirs SW1/MsgUp ou SW2/MsgDown,
- soit en envoyant sur l'entrée port série (en ASCII) le numéro du message désiré, suivi du caractère #13 ($0D en hexa) ou #10 ($0A en hexa). Par exemple :
3[#13]
ou
12[#10]
Le numéro du message peut avoir une valeur comprise entre 1 et 200.

Remplacement des MAX7219 par des MAX7221
Les MAX7221 sont quasiment identiques aux MAX7219, le mode d'envoi des données diffère un peu et les fronts montants et descendants des signaux issus des sorties pour LED sont moins abruptes et provoquent donc moins de rayonnements (moins de perturbations EM). En théorie le logiciel actuel n'est pas prévu pour piloter des MAX7221 (pilotage SPI pour ce dernier). Cependant, j'ai remplacé 2 MAX7219 par des MAX 7221 (juste pour voir) et à ma grande surprise cela fonctionne. Hum... cela me surprend un peu car d'après le datasheet fabricant, la broche CS du MAX7221 doit être actuve durant le transfert des données, ce qui n'est pas le cas du MAX7219 dont la broche CS peut être activée après le transfert des données. Question : mes MAX7221 (eux aussi achetés à très bas prix en Chine) sont-ils vraiment des MAX7221 ?

Schéma 002b - MAX7219 et matrices LED 5x7

Schéma identique à celui de la version 002c, mais cette fois avec 10 matrices LED 5x7, soit au total 50 colonnes de 7 LED au lieu de 80 colonnes.

journal_lumineux_002b

Là on "gâche" un peu les ressources des MAX7219 puisqu'on n'utilise pas toutes leurs sorties. Le procédé pourrait paraître plus compliqué que quand on utilise toutes les sorties, car il faut "sauter" 3 sorties sur les huit. Mais la gymnastique que cela m'a demandé au niveau logiciel a été moins insupportable que je ne l'avais imaginé. A vrai dire et comme d'habitude, je suis d'abord parti sur une solution incroyablement complexe pour parvenir à un résultat correct, avant de me rendre compte qu'il me suffisait de modifier seulement quelques lignes de code. Je faisais pareil à l'école avec les exercices de maths. Vous croyez qu'il y a un rapport ?

Pourquoi utiliser des matrices de LED 5x7 points au lieu de matrices 8x8 ?
Parce qu'on me l'a gentiment demandé. L'avantage de l'approche "circuit générique" que j'ai adoptée ici permet finalement d'utiliser au choix des afficheurs 8x8 ou 7x5, il suffit de mettre le bon logiciel dans le PIC...

Choix de la mémoire EEPROM externe

Il existe de nombreuses références de mémoire EEPROM externe, principalement prévues pour un bus I2C. Pour commencer, j'ai choisi de travailler avec une M24C64 de ST, pour son prix raisonnable et pour ses caractéristiques. Comme l'idée est de stocker et de rappeler à volonté les messages à afficher, je ne voulais pas que le système prenne trop de temps pour les cycles de lecture et surtout d'écriture. Je souhaitais aussi pouvoir accéder directement à un bloc d'octets (32 ou 64 octets) plutôt que de devoir accéder à chaque octet de façon individuelle. Cela est beaucoup plus rapide (sur ma maquette, je suis passé de 600 ms pour lecture écriture de 32 octets en mode individuel, à moins de 10 ms en lecture/écriture par bloc/page). En outre, la M24C64 dispose de 3 broches d'adresse physique (E0 à E2), ce qui permet d'implanter 8 puces sur le même bus sans quasiment rien modifier côté matériel, et disposer ainsi d'un espace mémoire de 512K ! En installant 8 mémoires externes de 64 K au lieu d'une seule, on dispose également de 512K d'espace mémoire et on pourrait traiter 2000 messages de 32 caractères ou 250 messages de 255 caractères. Pour l'heure je n'utilise qu'un seul circuit intégré mémoire de 64K et dispose donc de 8 KO partagés en 256 messages de 32 octets chacun. Mais comme je suis très curieux et que j'aime expérimenter, j'ai déjà commandé plusieurs autres mémoires : 24LC64 (64K), 24AA256 (256K) et 24FC512 (512K). A priori, toutes ces références devraient fonctionner avec mon journal, confirmation très bientôt !

Modes de programmation

Les deux modes de programmation décrits ci-après (en local ou depuis un ordinateur) sont valables pour les trois versions 002(a), 002b et 002c. Quelque soit le mode de programmation utilisé, les modifications sont sauvegardées en EEPROM et conservées après coupure de l'alimentation. Chaque message peut contenir jusqu'à 30 caractères.

Programmation en local (avec boutons-poussoirs)
Dans ce mode, la programmation se fait en autonome (ordinateur non requis).
- Presser le bouton-poussoir SW7/Prog pour passer en mode d'édition. Le numéro du message actuellement sélectionné apparaît en début de ligne.
- Sélectionner si besoin le message désiré à l'aide des boutons-poussoirs SW1/MsgUp ou SW2/MsgDown.
- Presser les boutons-poussoirs SW5/ChrUp et/ou SW6/ChrDown pour choisir le premier caractère du message à afficher.
- Presser le bouton-poussoir SW4/Right pour permettre de modifier le second caractère du message.
- Presser les boutons-poussoirs SW5/ChrUp et/ou SW6/ChrDown pour choisir le second caractère du message à afficher.
- Renouveler cette opération jusqu'à ce que tous les caractères du message soient saisis. Pour revenir en arrière, utiliser le bouton-poussoir SW3/Left.
- Pour finir, presser le bouton-poussoir SW8/Save pour enregistrer le message et sortir du mode d'édition. Attention, la fin du message est définie par le caractère le plus à gauche, c'est-à-dire celui qui suit immédiatement le numéro du message [xxx]. Pour sortir du mode d'édition sans sauvegarder le message en cours, presser le bouton SW7/Prog.

Programmation depuis un ordinateur (liaison série RS232/USB)
Dans ce mode, la programmation se fait avec un PC doté d'un émulateur terminal et relié par liaison série (voir paragraphe Mise en oeuvre de la liaison série). Le texte à afficher doit être envoyé sous forme série (octet après octet) sur l'entrée Rx1 de l'UART du PIC, à la vitesse de 19200 bauds et au format ASCII (texte standard) sous la forme suivante :
xxx=Texte[CR]
Il doit commencer par le numéro (xxx) du texte à créer ou à modifier suivi du signe "égal", comporter les caractères à afficher et être terminé par un octet de valeur décimale #13 ($0D en hexa) ou #10 ($0A en hexa). Dans la pratique, la pression sur la touche ENTREE du clavier de l'ordinateur fait l'affaire pour indiquer la fin du message. Par exemple :
3=Les portes du Penitencier[#13]
ou
12=BIERE INTERDITE SUR CONSOLE[#10]
Le numéro du message (xxx) peut avoir une valeur comprise entre 0 et 200. Le message 0 est celui qui est affiché au démarrage.

Mise en oeuvre de la liaison série
La liaison entre le journal lumineux et le système qui le commande (ordinateur ou microcontrôleur) est de type bi-directionnelle série (COM/RS232, 19200 bauds, 8 bits Data, 1 bit Stop, sans parité). La partie matérielle à mettre en oeuvre dépend du contexte d'utilisation et en particulier de la distance qui sépare les deux équipements :

adaptateur_usb_rs232_001a

Le convertisseur USB/TTL RS232 que je me suis procuré (photo ci-avant, acheté 1,50 euro) est inclus dans le connecteur USB lui-même, je n'ai que trois fils à raccorder au journal pour disposer d'une liaison fonctionnelle (port COM virtuel dans Windows). Aucun autre composant à ajouter ! A savoir : il existe aussi des modules miniatures prêts à l'emploi qui comportent tout le nécessaire pour assurer la conversion bi-directionnelle TTL/RS232. J'en ai acheté plusieurs (5 modules pour 2 euros, équipés du MAX232) et ils fonctionnent bien. Exemples.

Prototypes

Maquette réalisée pour les schémas 002c et 002b, avec matrices LED 8x8 et MAX7219. Pour des questions de coût et parce que ce montage est un prototype réalisé pour mes propres besoins, j'ai commandé 10 modules d'affichage en kit dotés de la matrice 8x8 LED et d'un MAX7219. A 20 euros les 10 modules on peut se douter que les MAX7219 ne sont pas des originaux (contrefaçon), mais tout fonctionne comme attendu.

max7219_led8x8_001a max7219_led8x8_001b max7219_led8x8_001c max7219_led8x8_001d

L'affichage fixe et le défilement (de droite à gauche) fonctionnent parfaitement. Comme j'ai branché 6 blocs d'affichage sur ma platine de développement et pour ne pas trop solliciter cette dernière, j'ai réglé la luminosité au minimum pour un courant consommé moyen raisonnable. A terme, l'alimentation de l'ensemble sera bien sûr suffisamment dimensionnée pour supporter la luminosité max en permanence.

max7219_led8x8_001e journal_lumineux_002c_proto_001b

Pour les tests du schéma 002b avec les afficheurs 5x7, j'ai utilisé mes matrices 8x8 que j'ai "bridées" : activation de 5 colonnes sur les 8 et multiplexage lui aussi bridé dans les MAX7219 (valeur de l'octet ScanLimit $0B ajustée à 4).
La mémorisation des textes à afficher est désormais implémentée (voir Nota), avec une mémoire externe I2C de type M24C64 (8K*8) ou M24FC512 (64K*8). La création ou modification des textes via liaison série est également opérationnelle, vérifié sur mon second proto avec mon logiciel ComTools. Vidéo à venir pour démonstration de l'objet en action.

journal_lumineux_002c_proto_002a journal_lumineux_002c_proto_002b journal_lumineux_002c_proto_002c

Nota : j'ai essayé plusieurs mémoires. Pas de soucis avec la mémoire M24C64 ni avec la mémoire 24FC512, mais dysfonctionnement observé avec la mémoire 24LC64 (enregistrement pas toujours réussi, même avec un délai élevé après chaque cycle d'écriture). Tant qu'à faire et puisque cela fonctionne bien, j'ai finalement adopté la 24FC512.

Important : l'alimentation doit vraiment être soignée et correctement distribuée, avec un découplage individuel par cellule RC pour chaque MAX7219 (1 ohm + 47 uF, la résistance de 1 ohm peut éventuellement être abaissée ou supprimée selon longueur des fils ou pistes d'alim). Les liaisons entre tous les MAX7219 (Data et Clock) doivent être courtes. Avec mon second prototype, j'ai observé quelques défauts d'affichage quand la luminosité est au max et avec une alim dont le courant de sortie est limité à 1 A (alim bas prix dont je doute parfois un peu). Ces défauts d'affichage peuvent prendre plusieurs formes :
- extinction aléatoire d'un module (trou fixe dans le message)
- apparition de lignes verticales non désirées
- module plus (ou moins) lumineux que les autres.
Il faut dire aussi que j'aime prendre des risques : avez-vous vu comment mes modules sont alimentés ? A la chaîne ! C'est la pire des choses à faire et je l'ai faite. Et en plus avec des circuits qui ne sont (à priori) pas des "originaux" et qui peuvent... dysfonctionner ! Pour diminuer les risques, j'ai réorganisé le câblage en étoile (voir photos ci-après) et ai utilisé une alim de labo 5 V / 5 A. Et cette fois plus de problème. Ou pour être plus exact, un ou deux problèmes d'affichage ponctuels et rarissimes, probablement dus au fait que l'ensemble n'est pas mis en boîte (non protégé contre les parasites environants).

journal_lumineux_002c_proto_002f journal_lumineux_002c_proto_002e

Les captures réalisées avec mon oscillo numérique Picoscope sur les lignes Data (en rouge) et Clock (en bleu) attestent de signaux assez propres.

journal_lumineux_002_graphe_001b

Il va de soi que pour une fiabilité (presque totale) une réalisation très soignée s'impose. Ne faites donc pas comme moi. Pour ma part, et pour corriger au fil de l'eau tout éventuel défaut, j'ai ajouté dans le logiciel une réinitialisation des MAX7219 avant chaque nouveau défilement de texte. Cela ne prend pas beaucoup de ressources processeur, pourquoi s'en priver ? Je sais bien qu'il s'agit là d'une méthode barbare conçue pour cacher la misère, mais j'assume car au final... cela fonctionne et c'est ce que je voulais.

Vidéo démo
Très vite fait, je ferai mieux quand j'aurai le temps.
http://www.sonelec-musique.com/videos/electronique_journal_lumineux_002c_proto_002b.avi

Prototype de Jean-Michel K.
Circuit réalisé sur la base du schéma 002b avec 10 afficheurs 5x7 points et MAX7221 (également testé avec succès avec MAX7219).

journal_lumineux_002b_proto_jmk_001a journal_lumineux_002b_proto_jmk_001c

Le circuit fonctionne bien en mode autonome et quand il est relié au looper 004b.

journal_lumineux_002b_proto_jmk_001b journal_lumineux_002b_proto_jmk_001d

Vidéo de démo, là encore vite faite avec un petit APN :
http://www.sonelec-musique.com/videos/electronique_journal_lumineux_002b_proto_jmk_001a.avi

Et le circuit 002(a) ?
Non testé en grandeur réelle mais simulé avec succès. Simple manque de temps...

Logiciel du PIC

Fichiers binaires compilés prêt à flasher (*.hex) disponible dans l'archive suivante, pour versions 002(a), 002b et 002c. Attention, version 002(a) simulée avec succès mais pas testée en réel.
Journal lumineux 002.zip (LE) - 18F46K22 - (version du 12/06/2015) - Version limitée à 4 messages 
Si vous souhaitez recevoir par la poste un PIC préprogrammé et prêt à utiliser, merci de consulter la page PIC - Sources.

Circuit imprimé

Non réalisé.

Historique

19/07/2015
- Ajout photos prototype de Jean-Michel K. avec afficheurs 5x7 et MAX7221 (schéma 002b).
14/06/2015
- Mise à jour des logiciels 002(a), 002b et 002c pour permettre un enregistrement plus fiable avec les mémoires EEPROM I2C "un peu lentes".
31/05/2015
- Construction d'un second prototype et vérification fonctionnement avec mémoires M24C64, 24LC64 et 24FC512.
- Modification de l'emplacement des touches du clavier pour permettre l'utilisation d'un joystick à point commun pour éditer plus facilement les textes en mode local.
17/05/2015
- Première mise à disposition.