Afficheur 7 segments MAX7219 avec Arduino

Définir des caractères

Dans ce paragraphe, nous allons voir comment définir nos propre caractères en définissant les segments à allumer pour le caractère ASCII désiré.

La bibliothèque bibliothèque « LedControl » offre la méthode « setChar() » pour l’affichage de caractères. Malheureusement,  les caractères disponibles avec cette méthode sont limités à la liste suivante:

‘0’,’1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9′,’0′, ‘A’,’b’,’c’,’d’,’E’,’F’,’H’,’L’,’P’,’.’,’-‘,’_’ et l’espace.

Heureusement, cette bibliothèque propose également la méthode « setRow() » qui prend comme:

  • 1er paramètre le numéro d’afficheur
  • 2ème l’index du chiffre de l’afficheur concerné
  • 3ème paramètre le code binaire de l’état des segments désirés.

Comment se construit le code binaire de l’état des segments ?

Si l’on désigne l’état des segments de chaque caractère de l’afficheur par les lettres ‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’ selon le schéma suivant:

Identification des segments de l'afficheur7 segments

Alors le code binaire de l’état d’un segment s’écrit sous la forme d’un octet dont les 8 bits sont codés dans l’ordre HABCDEFG avec la valeur de chaque bit est

  • à 1 si le segment est allumé,
  • à 0 s’il est éteint.

En prenant l’exemple du mot « COUCOU », nous avons besoin des lettres ‘C’, ‘O’ et ‘U’.

Lettre C avec l'afficheur 7 segments Lettre O avec l'afficheur 7 segments Lettre U avec l'afficheur 7 segments

Ce qui se traduit en valeur hexadécimale (dernière colonne Hex) :

Lettre H A B C D E F G  Bin  Hex
C 0 1 0 0 1 1 1 0  01001110 0x4E
O 0 1 1 1 1 1 1 0  01111110 0x7E
U 0 0 1 1 1 1 1 0  00111110 0x3E

Avec cette méthode, nous déduisons le code logiciel suivant pour écrire le mot « Coucou »:

// Déclaration des librairies utilisées
#include "LedControl.h" // Bibliothèque de gestion de l'afficheur MAX7219 7 segments

// Déclarations globales
LedControl afficheur_g=LedControl(11/*Broche DIN - Jaune*/, 12/*Broche CLK - Bleu*/, 10/*Broche CS - Vert*/); // Initialisation du contrôleur de l'afficheur 7 segments

// Fonction de démarrage, s'exécute une seule fois:
void setup()
{
    afficheur_g.shutdown(0,false); // Allume l'afficheur
    afficheur_g.setIntensity(0,7); // Définit la luminosité (valeur de 0 à 15)
    afficheur_g.setRow(0, 6, 0x4E); // Lettre C
    afficheur_g.setRow(0, 5, 0x7E); // Lettre O
    afficheur_g.setRow(0, 4, 0x3E); // Lettre U
    afficheur_g.setRow(0, 3, 0x4E); // Lettre C
    afficheur_g.setRow(0, 2, 0x7E); // Lettre O
    afficheur_g.setRow(0, 1, 0x3E); // Lettre U
}

// Fonction principale du programme, s'exécute en boucle:
void loop()
{

}

Définir les segments de la table ASCII:

Vous conviendrez avec moi que l’utilisation d’un code hexadécimal pour désigner un caractère n’est pas très pratique et rend difficile la lecture du code. C’est pourquoi je vous propose de définir dans un tableau C les segments à afficher pour les 128 caractères du code ASCII. En utilisant comme index du tableau la valeur du code ASCII, nous pouvons réaliser une conversion automatique des caractères ASCII en code hexadécimal des segments à afficher.

Dernière précision, le tableau utilise 128 octets d’espace mémoire aussi il est préférable de spécifier au compilateur de stocker sa définition en flash plutôt qu’en SRAM afin d’économiser cette dernière. Ceci est possible grâce à:

Pour améliorer la lisibilité du code logiciel et faciliter sa réutilisation, j’ai choisi de définir ce tableau dans un fichier séparé nommé « Caracteres7Segments.h ».  Pour que ce fichier puisse être utilisé dans votre fichier source principal et visible sous l’éditeur Arduino, il est nécessaire de:

  • le déposer dans le même répertoire projet
  • ajouter l’instruction « #include « Caracteres7Segments.h » au début du code de votre fichier source principal.

Voici le contenu du fichier « Caracteres7Segments.h » :

/*
  Caracteres7Segments.h - Definition des segments à allumer pour chaque caractère ASCII.
  Cree par tropratik.fr - Version 1.0 du 16 octobre 2020.
*/
#ifndef Caracteres7Segments_h
#define Caracteres7Segments_h

#include "Arduino.h"

// Declaration en Flash de la definition des segments à allumer pour chaque caractère ASCII
const PROGMEM uint8_t tab_caracteres7_segments[] =
{
    0x00, // 000 [Espace]
    0x00, // 001 [Espace]
    0x00, // 002 [Espace]
    0x00, // 003 [Espace]
    0x00, // 004 [Espace]
    0x00, // 005 [Espace]
    0x00, // 006 [Espace]
    0x00, // 007 [Espace]
    0x00, // 008 [Espace]
    0x00, // 009 [Espace]
    0x00, // 010 [Espace]
    0x00, // 011 [Espace]
    0x00, // 012 [Espace]
    0x00, // 013 [Espace]
    0x00, // 014 [Espace]
    0x00, // 015 [Espace]
    0x00, // 016 [Espace]
    0x00, // 017 [Espace]
    0x00, // 018 [Espace]
    0x00, // 019 [Espace]
    0x00, // 020 [Espace]
    0x00, // 021 [Espace]
    0x00, // 022 [Espace]
    0x00, // 023 [Espace]
    0x00, // 024 [Espace]
    0x00, // 025 [Espace]
    0x00, // 026 [Espace]
    0x00, // 027 [Espace]
    0x00, // 028 [Espace]
    0x00, // 029 [Espace]
    0x00, // 030 [Espace]
    0x00, // 031 [Espace]
    0x00, // 032 [Espace]
    0x00, // 033 [Espace]
    0x00, // 034 [Espace]
    0x00, // 035 [Espace]
    0x00, // 036 [Espace]
    0x00, // 037 [Espace]
    0x00, // 038 [Espace]
    0x20, // 039 '
    0x00, // 040 [Espace]
    0x00, // 041 [Espace]
    0x00, // 042 [Espace]
    0x00, // 043 [Espace]
    0x00, // 044 [Espace]
    0x01, // 045 -
    0x80, // 046 .
    0x00, // 047 [Espace]
    0x7E, // 048 0
    0x30, // 049 1
    0x6D, // 050 2
    0x79, // 051 3
    0x33, // 052 4
    0x5B, // 053 5
    0x5F, // 054 6
    0x70, // 055 7
    0x7F, // 056 8
    0x7B, // 057 9
    0x00, // 058 [Espace]
    0x00, // 059 [Espace]
    0x00, // 060 [Espace]
    0x48, // 061 =
    0x00, // 062 [Espace]
    0x00, // 063 [Espace]
    0x00, // 064 [Espace]
    0x77, // 065 A
    0x7F, // 066 B
    0x4E, // 067 C 
    0x7E, // 068 D 
    0x4F, // 069 E 
    0x47, // 070 F 
    0x5E, // 071 G 
    0x37, // 072 H 
    0x30, // 073 I 
    0x3C, // 074 J 
    0x37, // 075 K 
    0x0E, // 076 L 
    0x55, // 077 M 
    0x15, // 078 N 
    0x7E, // 079 O 
    0x67, // 080 P 
    0x73, // 081 Q 
    0x77, // 082 R 
    0x5B, // 083 S 
    0x46, // 084 T 
    0x3E, // 085 U 
    0x27, // 086 V
    0x3F, // 087 W 
    0x25, // 088 X 
    0x3B, // 089 Y 
    0x6D, // 090 Z 
    0x39, // 091 [
    0x00, // 092 [Espace]
    0x0F, // 093 ]
    0x00, // 094 [Espace]
    0x08, // 095 _
    0x00, // 096 [Espace]
    0x7D, // 097 a 
    0x1F, // 098 b 
    0x0D, // 099 c 
    0x3D, // 100 d 
    0x6f, // 101 e 
    0x47, // 102 f 
    0x7B, // 103 g 
    0x17, // 104 h 
    0x10, // 105 i 
    0x38, // 106 j 
    0x17, // 107 k 
    0x06, // 108 l 
    0x55, // 109 m 
    0x15, // 110 n 
    0x1D, // 111 o 
    0x67, // 112 p 
    0x73, // 113 q 
    0x05, // 114 r 
    0x5B, // 115 s 
    0x0F, // 116 t 
    0x1C, // 117 u 
    0x23, // 118 v 
    0x2B, // 119 w 
    0x25, // 120 x 
    0x33, // 121 y 
    0x6D, // 122 z 
    0x00, // 123 [Espace] 
    0x30, // 124 | 
    0x00, // 125 [Espace] 
    0x00, // 126 [Espace] 
    0x00  // 127 [Espace]
};

#endif

Le programme précédent devient donc:

// Déclaration des librairies utilisées
#include "LedControl.h" // Bibliothèque de gestion de l'afficheur MAX7219 7 segments

// Déclaration des fichiers du projet à inclure
#include "Caracteres7Segments.h"

// Déclarations globales
LedControl afficheur_g=LedControl(11/*Broche DIN - Jaune*/, 12/*Broche CLK - Bleu*/, 10/*Broche CS - Vert*/); // Initialisation du contrôleur de l'afficheur 7 segments

// Fonction de démarrage, s'exécute une seule fois:
void setup()
{
    afficheur_g.shutdown(0,false); // Allume l'afficheur
    afficheur_g.setIntensity(0,7); // Définit la luminosité (valeur de 0 à 15)
    afficheur_g.setRow(0, 6, pgm_read_byte(&tab_caracteres7_segments['C']));
    afficheur_g.setRow(0, 5, pgm_read_byte(&tab_caracteres7_segments['O']));
    afficheur_g.setRow(0, 4, pgm_read_byte(&tab_caracteres7_segments['U']));
    afficheur_g.setRow(0, 3, pgm_read_byte(&tab_caracteres7_segments['C']));
    afficheur_g.setRow(0, 2, pgm_read_byte(&tab_caracteres7_segments['O']));
    afficheur_g.setRow(0, 1, pgm_read_byte(&tab_caracteres7_segments['U']));
}

// Fonction principale du programme, s'exécute en boucle:
void loop()
{

}

Après la compilation du programme puis son transfert dans l’Arduino. Vous devez obtenir le résultat suivant:

Montage Arduino pour piloter un afficheur 7 segments MAX7219 en I2C

Ça y est vous savez définir vos propres caractères sur un afficheur 7 segments. Rendez-vous à la dernière étape de cet article pour réaliser un programme faisant défiler un texte sur l’afficheur (page suivante).

Laisser un commentaire