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:

• 1^er 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:

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’.

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

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 à:

• l’utilisation du mot clef “PROGMEM“ lors de la définition du tableau
• l’utilisation de l’instruction “pgm_read_byte()” pour accéder à la valeur du tableau.

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:

Ç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).