mercredi 27 mai 2020

MAX7219 : affichage matriciel




MAX7219 : affichage matriciel



Nous allons parler aujourd'hui de modules MAX7219 permettant de réaliser un afficheur matriciel à 64 LEDs.
Nous allons examiner certains aspects que l'on ne voit pas dans les nombreux tutoriels qui foisonnent sur le WEB :
  • alimentation et découplage
  • affichage de caractères accentués
  • affichage clignotant
  • utilisation avec un ESP32 (y compris les touches capacitives)
  • éviter certains pièges
Ces modules existent sous forme unitaire comme ceci :
Module DIP

Module CMS


Dans le premier cas le circuit MAX7219 est un modèle DIP apparent.

Le deuxième module est équipé d'un circuit CMS situé sous l'afficheur, plus facile à organiser en panneau multi-modules jointifs.

Ils existent aussi sous forme de panneaux de 4 modules CMS ou plus :

Module quadruple


1. Le matériel

1.1. Pilotage

Ces modules se pilotent en SPI. ils sont équipés de 5 broches d'entrée (VCC, GND, DIN, CS, CLK).
Il peuvent être chaînés, ils possèdent donc également 5 broches de sortie (VCC, GND, DOUT, CS, CLK) que l'on reliera aux broches d'entrée du module suivant:


1.2. Alimentation

En fonction du nombre de modules et de la luminosité prévue il faut compter environ 250mA pour 4 modules alimentés affichant du texte avec la luminosité maximale.
La consommation dépendra aussi de la police de caractères utilisées (certaines polices allument plus de LEDs que d'autres).

Le câblage devra donc être réalisé avec des fils de section suffisante.

Bien entendu si les afficheurs sont amenés à afficher des bitmaps plus ou moins pleins, cette consommation sera également supérieure.

Le courant maximal par module (ce courant correspond à l'affichage de 4 carrés pleins à luminosité maximale) dépend de l'implémentation du constructeur, en particulier de la valeur d'une résistance ISET (voir la datasheet) qui fixe ce courant.

1.2.1. Alimentation par USB
Si l'on alimente un ARDUINO ou un ESP32 par son connecteur USB il faudra tenir compte de deux contraintes :
  • le courant maximal fourni par l'alimentation ou le port USB de l'ordinateur
  • la courant maximal admissible par la diode ou le fusible de protection de la carte
La diode de protection d'une carte ARDUINO ou ESP32 admet en général assez peu de courant :
  • ESP32 DEV-KIT : diode 1A
  • ARDUINO NANO : diode 1A
  • ARDUINO MEGA : fusible 500mA
On voit que la limite est assez vite atteinte si l'on désire utiliser plusieurs afficheurs.

1.2.2. Alimentation par VIN
Il est pratiquement impossible de piloter un grand nombre de ces afficheurs en alimentant un ARDUINO par VIN pour ensuite alimenter les afficheurs par la broche 5V.
Je vous renvoie à cet article :
Voir le paragraphe 3.2. Broche VIN.

Si l’on alimente l'ARDUINO en 7.5V, le courant maximal disponible sur la broche 5V sera de 480mA.

1.2.3. Alimentation dédiée
Pour piloter un grand nombre d'afficheurs il serait préférable d'alimenter les afficheurs directement en 5V à l'aide d'une alimentation dédiée de puissance suffisante. Le microcontrôleur pourra également être alimenté directement en 5V à l'aide de la même alimentation.

Sur les modules quadruples (256 LEDs) en ma possession le courant maximal (toutes les LEDs allumées à luminosité maximale) est égal à 650mA, c'est à dire 160mA par module, donc 2.5mA par LED. Pendant la phase de maquettage j'alimente les afficheurs avec une alimentation 5V séparée, afin d'éviter de surcharger le port USB sur lequel est branché l'ESP32.

Pour un projet définitif il faut faire un bilan sérieux des consommations. Exemple avec 2 afficheurs quadruples + ESP32 :
  • connexion WIFI ESP32 : 450mA maxi
  • ESP32 connecté : 120mA maxi
  • affichage plein sur un seul afficheur (test des LEDs au démarrage) :
    • 1 afficheur : 650mA
    • ESP32 : 120mA
  • affichage de texte sur deux afficheurs
    • 2 afficheurs : 500mA
    • ESP32 : 120mA
La consommation ne devrait pas excéder 770mA au démarrage pendant quelques secondes, et retomber à 620mA ensuite. Une alimentation 5V 1A sera nécessaire.
Si toutes les LEDs des deux afficheurs étaient allumés simultanément au démarrage il faudrait plutôt opter pour une alimentation pouvant débiter au minimum 1.5A.

Attention : une alimentation à découpage ne se comporte pas comme une alimentation linéaire.
Une alimentation linéaire peut encaisser une surcharge de faible durée sans problème car la protection de son régulateur est souvent thermique, donc lente.
Une alimentation à découpage provoque une coupure de sa sortie au moindre dépassement de son courant maximal, même bref.

1.3. Découplage

Il arrive qu'aléatoirement un ou plusieurs afficheurs n'affichent plus rien si la luminosité devient élevée, dans le cas où l'on conçoit un logiciel capable de régler celle-ci par exemple. Il s'agit probablement de pics de courant générant des baisses de tension d'alimentation et qui plantent le MAX7219.

Après différents essais, pour 8 afficheurs j'obtiens de bons résultats avec une luminosité moyenne en connectant un condensateur de 220µF en parallèle sur l'alimentation des afficheurs, entre VCC et GND.
La valeur de ce condensateur monte à 3300µF si je veux afficher sans problème des carrés pleins à luminosité maximale sur seulement 4 afficheurs.

Cette valeur est bien entendu à ajuster en fonction :
  • du nombre d'afficheurs
  • du type d'alimentation, de sa puissance
  • de la longueur des câbles d'alimentation, de leur section
Il est également possible de placer plusieurs condensateurs de plus faible valeur sur chaque afficheur ou chaque groupe d'afficheurs.

Après mise en place des condensateurs il faut tester le montage avec un petit sketch qui affiche des informations suffisamment représentatives de ce que l'on compte afficher.

2. Le logiciel

2.1. Orientation

Il faut faire attention lors de l'achat à choisir les modules en fonction de ce que l'on désire afficher. Classiquement lorsque l'on chaîne plusieurs modules en ayant l'intention d'y afficher du texte on a tendance à les aligner horizontalement, sur une ou plusieurs lignes.

On constate assez vite que l'on va se retrouver confrontés à deux problèmes :
  • un problème d'orientation de chaque module
  • un problème d'ordre des modules entre eux
La plupart des librairies considèrent que le pixel 0:0 se trouve dans le coin supérieur gauche, lorsque les broches d'entrée sont situées sur le dessus du module.
Mais il est parfaitement possible qu'un constructeur puisse choisir une orientation différente, et comme les vendeurs ne précisent pas ce genre de détail il est donc difficile de savoir comment orienter les modules sans les essayer.

Les librairies considèrent également que les modules sont chaînés de la droite vers la gauche. Si cet ordre est inversé, la chaîne ABCD sera affichée DCBA.

Pour résumer, lorsque l'on chaîne plusieurs modules ensemble, il est plus que probable que l'on obtienne un affichage mal orienté ou inversé.

Lorsque l'on dispose de modules unitaires il est facile de les disposer côte à côte et de les chaîner pour obtenir un affichage correct des caractères.

A noter que les modèles CMS offriront 4 possibilités d'orientation, ce qui ne sera pas le cas des modèles DIP. Les modèles DIP ne permettront pas non plus d'accoler les afficheurs sur plus d'une ligne, à moins de tolérer un interligne.

On ne peut donc que recommander l'achat de modules CMS simples et de les combiner selon la librairie utilisée.

Mais que se passe t-il avec un module quadruple ? Là aussi tout dépend du constructeur, et de la librairie choisie. Si ces modules sont chaînés de droite à gauche et que la librairie ne permet pas de changer l'orientation, le résultat sera celui-ci :


Il peut probablement arriver que la combinaison modules / librairie ne donne pas de résultat satisfaisant.

Il existe un certain nombre de librairies permettant de gérer ces afficheurs. Malgré tout la seule qui permette de choisir l'orientation des modules est celle-ci :

Cette autre librairie sera nécessaire :

La librairie MD_PAROLA permet de choisir entre 4 orientations :
  • PAROLA_HW : chaînage horizontal affichage inversé (en miroir)
  • GENERIC_HW : chaînage vertical
  • ICSTATION_HW : chaînage horizontal gauche-droite
  • FC16_HW : chaînage horizontal droite-gauche
La majeure partie des blocs de 4 afficheurs vendus sur ALIEXPRESS se pilotent en utilisant le paramètre FC16_HW :

La librairie possède pas mal de fonctionnalités utiles :
  • scrolling horizontal et vertical
  • justification à gauche, à droite, au centre
  • réglage de l'espace inter-caractères
  • gestion de zones d'affichage séparées
  • etc.
Une autre librairie fonctionne avec les blocs de 4 afficheurs chaînés de droite à gauche, celle de Nick Gammon :

D'autres librairies ne fonctionneront qu'avec des afficheurs simples chaînés de bas en haut avec des fils :

Il faut avouer que dans le monde des librairies MAX7219 c'est un peu la jungle.
Il est important d'évaluer les possibilités de quelques unes afin de ne pas s'engager dans une voie sans issue qui ne permettrait pas d'obtenir le résultat escompté.

2.2. Le bus SPI

La librairie MD_PAROLA permet de piloter l'afficheur en utilisant soit le bus SPI natif du microcontrôleur soit un bus SPI émulé (bitbanged SPI).
Dans le premier cas on reliera l'afficheur aux pins SPI du microcontrôleur :
  • DIN : MOSI (D11 sur un ARDUINO)
  • CLK : CLK (D13 sur un ARDUINO)
  • CS : SS (D10 sur un ARDUINO) ou un autre choix
Dans le deuxième cas, le choix des broches est libre, mais la communication sera moins rapide.

Exemple :
// Hardware SPI connection
MD_Parola P = MD_Parola(MD_MAX72XX::FC16_HW, CS_PIN, MAX_DEVICES);

// Arbitrary output pins
MD_Parola P = MD_Parola(MD_MAX72XX::FC16_HW, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);

MAX_DEVICES représente le nombre d'afficheurs à chaîner.

Dernière chose, cette librairie fonctionne aussi bien avec un ARDUINO qu'avec un ESP8266 ou un ESP32.

2.3. Afficher des messages

La librairie MD_PAROLA, comme beaucoup d'autres d'ailleurs, ne recopie pas les messages qu'on lui demande d'afficher. Il s'en suit que ces chaînes de caractères doivent être impérativement stockées dans des variables globales ou statiques.
Une variable locale à une fonction ne conviendra pas, car son contenu n'est pas persistant.

2.4. L'UTF8

Moyennant la création d'une police de caractères adaptée et d'une petite fonction de conversion il est parfaitement possible d'afficher des caractères accentués.
Cette police est fournie dans l'exemple Parola_UFT-8_Display.

Le code de conversion :

2.5. Affichage clignotant

On pourrait bêtement penser qu'il suffit d'afficher un espace à la place des deux points d'une horloge toutes les deux secondes pour obtenir 2 points clignotants.
Il n'en est rien.
Cela marcherait avec une police de largeur fixe, celle de la librairie est à largeur variable.
Le caractère ':' fait 1 pixel de large, l'espace en fait deux. On obtiendrait donc un affichage dont la largeur change toutes les secondes, peu esthétique.

Il faut donc créer un espace simple dans notre police de caractères. J'ai utilisé le caractère 31 (0x1F) pour cet usage (l'espace étant le 32).

  1, 0,      // 31 - 'Small space'
  2, 0, 0,        // 32 - 'Space'


Il suffit donc d'utiliser ce caractère pour afficher un espace étroit à la place des 2 points, toutes les 2 secondes :

  static char timeString[10];
  struct tm timeinfo;
      // ...
      getLocalTime(&timeinfo);
      if (timeinfo.tm_sec % 2) {
        strftime(timeString, sizeof(timeString), "%H:%M", &timeinfo);
      }
      else {
        strftime(timeString, sizeof(timeString), "%H\x1f%M", &timeinfo);
      }
      hDisplay.displayText(timeString, PA_CENTER, 0, 0, PA_PRINT, PA_NO_EFFECT);

3. Le projet

Le petit projet exemple se propose d'implémenter une horloge sur la base d'un ESP32, avec les fonctionnalités suivantes :
  • affichage heure + minutes avec 2 points clignotants.
  • affichage de la date configurable :
    • jour de la semaine + jour du mois
    • jour + mois
    • jour + mois + année + saint du jour (avec scrolling)
  • luminosité réglable
  • gestion de l'heure par NTP avec changement d'heure été / hiver
  • configuration par 2 touches sensitives
  • configuration sauvegardée en FLASH
  • serveur WEB (brouillon)
La totalité des LEDs des deux afficheurs (afficheur de l'heure puis l'afficheur de la date) sont allumées au démarrage pendant une seconde chacun.

Le saint du jour est obtenu grâce au même moyen que sur le projet Afficheur TFT pour ESP8266 :
Voir paragraphe 5.1. Le service PHP.

Il conviendra d'adapter l'URL dans le fichier ephemeris.cpp si cette option est utilisée, sinon on la remplacera par une chaîne vide.

Le serveur WEB de l'ESP32 (vide pour le moment) pourra servir de page de configuration :
  • URL du serveur NTP
  • URL du serveur saint du jour
  • heure de réveil, d'alarme, etc.
  • etc.
Les deux afficheurs 4x8x8 sont câblés comme suit :
  • CLK : GPIO18
  • DIN : GPIO23
  • CS : GPIO26 et GPIO25

Les deux blocs d'afficheurs ne sont pas chaînés, ils sont simplement pilotés en parallèle avec deux pins CS différentes.

L'ESP32 est un classique DEV-KIT mais n'importe quel modèle peut convenir.

4. L'ESP8266

Attention : le hardware SPI de l'ESP8266 utilise les broches D5 D7 D8 (GPIO14 GPIO13 GPIO15) :

On a tendance à oublier, dans le code, que la broche 5 est la GPIO5 et non pas D5.

#define CLK_PIN    D5   // et non pas 5
#define DATA_PIN  D7   // et non pas 7
#define CS_PIN      D8   // et non pas 8

5. Téléchargement

Ce projet est disponible ici : 

6. Conclusion

Il faut bien avouer que ces afficheurs matriciel sont très attrayants. Ils permettent de réaliser des affichages visibles de loin et des animations intéressantes.

Il va sans dire que ce projet n'est qu'une première version appelée à évoluer.


Cordialement

Henri


à
Libellés : , , , ,

2 commentaires:

Inscription à : Publier les commentaires (Atom)