Panneau de 256 leds WS2812 et caractères perso

Bonsoir,

J'utilise des panneaux de 256 leds WS2812 pour divers projets avec les librairies :
Adafruit_GFX.h Adafruit_NeoMatrix.h Adafruit_NeoPixel.h

J'aurais aimé créé mes propres caractères 3 de large 5 de haut...

généralement on fait un tableau :

byte A[] [5] = {
    B111,
    B101,
    B111,
    B101,
    B101,
 }

Mais quelle valeur mettre dans ce tableau ?

@+

plus de détails ici

--> regardez comment ils définissent une police (et un fichier d'exemple)

je suis allez voir hier aussi dans la source de la librairie

#ifndef _GFXFONT_H_
#define _GFXFONT_H_

/// Font data stored PER GLYPH
typedef struct {
  uint16_t bitmapOffset; ///< Pointer into GFXfont->bitmap
  uint8_t width;         ///< Bitmap dimensions in pixels
  uint8_t height;        ///< Bitmap dimensions in pixels
  uint8_t xAdvance;      ///< Distance to advance cursor (x axis)
  int8_t xOffset;        ///< X dist from cursor pos to UL corner
  int8_t yOffset;        ///< Y dist from cursor pos to UL corner
} GFXglyph;

/// Data stored for FONT AS A WHOLE
typedef struct {
  uint8_t *bitmap;  ///< Glyph bitmaps, concatenated
  GFXglyph *glyph;  ///< Glyph array
  uint8_t first;    ///< ASCII extents (first char)
  uint8_t last;     ///< ASCII extents (last char)
  uint8_t yAdvance; ///< Newline distance (y axis)
} GFXfont;

#endif // _GFXFONT_H_

on defini le : pointeur, largeur,hauteur, ok
xAdvance, xOffset, yOffset pas compris

et dans l’exemple correspondant :

{49, 3, 3, 4, 0, -2},   // 0x41 'A'

par contre le pointeur devient index

il y a 49 = index , 3= largeur, 3= hauteur, 4 = xAdvance,3 = xOffset, -2 = yOffset .

Je ne comprend pas comment on peut allumer autant de led avec seulement 6 variables.

Je ne comprend pas comment on peut allumer autant de led avec seulement 6 variables.

Ces six variables ne définissent pas les bitmaps.

Dans le fichier exemple fourni par J-M-L le tableau Tiny3x3a2pt7bBitmaps contient les bitmaps.

Explication : Advanced topics | Creating Custom Symbol Fonts for Adafruit GFX Library | Adafruit Learning System

Entre nous j'espère que tu ne comptes pas bâtir une police complète à la main :sob:

En recherchant AdaFruit font converter tu trouveras des outils :

je peut tous créé dans le ino ?

je vais juste faire les 10 chiffres en 3*5

l'exemple donne sur 8 colonnes:

/*| X X X X . . . . |*/  0xf0,

exemple avec valeur au hazard :

byte A[] [5] = {
    0xf0,  /*| X X X X . . . . |*/
    0xa0, /*| X . X . . . . , |*/
    0x02, /*| . . . . . . X , |*/
    0xf0, /*| X X X X . . . . |*/
    0xf0, /*| X X X X . . . . |*/
 }

C'est ça ?

mais si je veut faire sur 3 colonnes ?

/| X . . |/ ?

@+

Si l’affichage est basé sur l’utilisation de la bibli Adafruit_GFX, le site Font Converter permet de créer des fichiers compatibles. On choisit la police, la taille, le style, le type d’écran et on place le fichier créé dans le répertoire Fonts de la bibliothèque (attention il sera effacé à chaque mise à jour de la bibli, donc à conserver autre part).

Un exemple de fichier créé (pour voir si c’est pertinent par rapport au problème posé) :

// Created by http://oleddisplay.squix.ch/ Consider a donation
// In case of problems make sure that you are using the font file with the correct version!
const uint8_t Aclonica_Regular_16Bitmaps[] PROGMEM = {

 // Bitmap Data:
 0x00, // ' '
 0xF7,0xBD,0xEF,0x71,0x8C,0x63,0x39,0xEE,0x00, // '!'
 0xFE,0xFE,0xEE,0xEE,0xEC, // '"'
 0x0F,0x87,0xE1,0xB0,0xFE,0x7F,0x8F,0x87,0xF3,0xFC,0x7E,0x1B,0x00, // '#'
 0x18,0x0C,0x0F,0x0F,0xE7,0xA3,0xE0,0xF8,0xBE,0xFE,0x1F,0x06,0x03,0x00, // '

0x21,0xCF,0x98,0xDB,0x8D,0xB0,0xDF,0x0F,0x60,0x0D,0xC1,0xF6,0x1B,0x63,0xB6,0x33,0xE6,0x1C, // ‘%’
0x3E,0x03,0xF8,0x1D,0xE0,0xE7,0x07,0xF0,0x3F,0x03,0xF9,0x1D,0xFE,0xE7,0xF7,0x9F,0x3F,0xFC,0x7F,0xC0,0x04,0x00, // ‘&’
0xEE,0xEE,0xE0, // ‘’’
0x18,0xC7,0x1C,0xE3,0x8E,0x38,0xE3,0x8E,0x38,0x71,0xC3,0x80, // ‘(’
0xC0,0xC1,0xC1,0xC3,0x87,0x0E,0x1E,0x3C,0x70,0xE1,0xC3,0x0E,0x38,0x00, // ‘)’
0x72,0xAF,0x9C,0xF9,0x40, // ‘*’
0x38,0x38,0xFE,0xFE,0x38,0x38, // ‘+’
0xEE,0xEE,0x40, // ‘,’
0xFD,0xF8, // ‘-’
0xEE,0xE0, // ‘.’
0x07,0x07,0x83,0x83,0xC1,0xC0,0xE0,0xF0,0x70,0x38,0x3C,0x1C,0x1E,0x00, // ‘/’
0x1F,0x83,0xFE,0x1C,0x79,0xE1,0xCF,0x0E,0x70,0x7B,0x83,0xDE,0x1C,0xF1,0xE3,0x8F,0x1F,0xF0,0x3F,0x00, // ‘0’
0xF8,0xF8,0x78,0x78,0x78,0x78,0x78,0x78,0x78,0x78,0xFE,0xFE, // ‘1’
0x1F,0xC1,0xFF,0x1E,0x3C,0x61,0xE1,0x0F,0x00,0xF0,0x3F,0x87,0xE0,0x3C,0x03,0xC0,0x1F,0xFD,0xFF,0xE0, // ‘2’
0x1F,0x83,0xFE,0x0E,0x78,0x23,0xC0,0x3C,0x07,0xE0,0x3F,0x82,0x1E,0x70,0xF7,0x87,0x9F,0xF8,0x3F,0x80, // ‘3’
0x01,0xC0,0x3C,0x1D,0xC3,0xDC,0x39,0xC7,0x9C,0x71,0xC7,0xFE,0xFF,0xE0,0x1C,0x01,0xC0,0x1C, // ‘4’
0x3F,0xE1,0xFF,0x0E,0x00,0x70,0x07,0xF8,0x3F,0xF1,0x87,0xC2,0x1E,0x30,0xF7,0x87,0x9F,0xF8,0x3F,0x80, // ‘5’
0x1F,0x81,0xFF,0x1E,0x39,0xE0,0x8F,0xFC,0x7F,0xF3,0xC7,0x9E,0x1E,0xF0,0xF7,0x8F,0x1F,0xF8,0x3F,0x00, // ‘6’
0xFF,0xDF,0xF8,0x0F,0x03,0xC0,0x78,0x1E,0x03,0xC0,0xF0,0x1E,0x03,0x80,0xF0,0x3E,0x00, // ‘7’
0x3F,0x83,0xFE,0x1C,0x70,0xE3,0xC7,0xBC,0x3F,0xE3,0xFF,0x9E,0x1C,0xE0,0xF7,0x8F,0x3F,0xF8,0x7F,0x80, // ‘8’
0x3F,0x83,0xFE,0x3C,0x79,0xC1,0xCE,0x0E,0x78,0xFB,0xFF,0x87,0xFC,0x41,0xE7,0x0E,0x3F,0xF0,0x7E,0x00, // ‘9’
0x67,0xBC,0xC0,0x03,0x9E,0xE0, // ‘:’
0x67,0xBC,0xC0,0x03,0x9E,0xE7,0x08, // ‘;’
0x04,0x39,0xE7,0x0C,0x1E,0x0F,0x06,0x04, // ‘<’
0xFE,0xFE,0xFE,0xFE, // ‘=’
0x81,0xC3,0xE1,0xE1,0xCF,0x3C,0x60,0x80, // ‘>’
0x1C,0x0F,0xE3,0xDE,0x31,0xE1,0x3C,0x07,0x81,0xE0,0x78,0x0C,0x01,0x80,0x70,0x0E,0x01,0xC0, // ‘?’
0x07,0x00,0x7F,0x07,0x06,0x18,0x0C,0xCF,0x5A,0x77,0x69,0x9C,0xA6,0x32,0x99,0xDB,0x77,0xEC,0xFF,0x18,0x00,0x3F,0x80,0x3E,0x00, // ‘@’
0x1F,0x81,0xFE,0x1E,0x78,0xE1,0xCF,0x0E,0x78,0x7B,0xC3,0xDF,0xDE,0xFE,0xE7,0x87,0x3C,0x39,0xE3,0x80,0x1C,0x01,0xC0, // ‘A’
0xFF,0x8F,0xFC,0xF1,0xEF,0x1E,0xF3,0xCF,0xF8,0xFF,0xEF,0x1E,0xF1,0xEF,0x1E,0xFF,0xEF,0xF8, // ‘B’
0x1F,0x83,0xFC,0x78,0xEF,0x06,0xF0,0x0E,0x00,0xE0,0x0F,0x00,0xF0,0x67,0x8E,0x3F,0xC1,0xF8, // ‘C’

0xE1,0xCE,0x31,0xEC,0x1F,0x01,0xE0,0x3C,0x07,0xC1,0xB8,0x73,0x9C,0x78, // ‘x’
0xE1,0xDE,0x39,0xC6,0x3D,0xC3,0xB0,0x76,0x07,0x80,0xF0,0x1E,0x01,0x80,0x30,0x0C,0x03,0x80,0x60,0x00, // ‘y’
0xFF,0x7F,0x83,0x83,0xC3,0xC1,0xC1,0xE1,0xE0,0xFF,0x7F,0x80, // ‘z’
0x3C,0xF9,0xC3,0x87,0x0E,0x3C,0x70,0xF0,0xE1,0xC3,0x87,0x8F,0x87,0x00, // ‘{’
0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xEE,0xE0, // ‘|’
0xF1,0xE1,0xE3,0xC7,0x8F,0x0F,0x1E,0x78,0xF1,0xE3,0xC7,0x1E,0x38,0x00 // ‘}’
};
const GFXglyph Aclonica_Regular_16Glyphs PROGMEM = {
// bitmapOffset, width, height, xAdvance, xOffset, yOffset
 {     0,   1,   1,   7,    0,    0 }, // ’ ’
 {     1,   5,  13,   7,    1,  -13 }, // ‘!’
 {    10,   8,   5,  10,    1,  -12 }, // ‘"’
 {    15,  10,  10,  11,    0,  -11 }, // ‘#’
 {    28,   9,  12,   9,    0,  -12 }, // ’



  {    42,  12,  12,  14,    1,  -12 }, // '%'
  {    60,  13,  13,  15,    1,  -12 }, // '&'
  {    82,   4,   5,   7,    1,  -12 }, // '''
  {    85,   6,  15,   8,    1,  -14 }, // '('
  {    97,   7,  15,   8,    0,  -14 }, // ')'
  {   111,   6,   6,   8,    1,  -12 }, // '*'
  {   116,   8,   6,  10,    1,   -9 }, // '+'
  {   122,   4,   5,   7,    1,   -3 }, // ','
  {   125,   7,   2,   9,    1,   -7 }, // '-'
  {   127,   4,   3,   6,    1,   -3 }, // '.'
  {   129,   9,  12,  10,    0,  -12 }, // '/'
  {   143,  13,  12,  15,    1,  -12 }, // '0'
  {   163,   8,  12,   9,    1,  -12 }, // '1'
  {   175,  13,  12,  14,    0,  -12 }, // '2'
  {   195,  13,  12,  14,    0,  -12 }, // '3'
  {   215,  12,  12,  13,    0,  -12 }, // '4'
  {   233,  13,  12,  14,    0,  -12 }, // '5'
  {   253,  13,  12,  15,    1,  -12 }, // '6'
  {   273,  11,  12,  12,    0,  -12 }, // '7'
  {   290,  13,  12,  15,    1,  -12 }, // '8'
  {   310,  13,  12,  15,    1,  -12 }, // '9'
  {   330,   5,   9,   7,    1,   -9 }, // ':'
  {   336,   5,  11,   7,    1,   -9 }, // ';'
  {   343,   7,   9,   9,    1,  -10 }, // '<'
  {   351,   8,   4,  11,    1,   -8 }, // '='
  {   355,   7,   9,   9,    1,  -10 }, // '>'
  {   363,  11,  13,  12,    0,  -13 }, // '?'
  {   381,  14,  14,  16,    1,  -12 }, // '@'
  {   406,  13,  14,  15,    1,  -12 }, // 'A'
  {   429,  12,  12,  14,    1,  -12 }, // 'B'
  {   447,  12,  12,  14,    1,  -12 }, // 'C'
  {   465,  13,  12,  15,    1,  -12 }, // 'D'
  {   485,  10,  12,  12,    1,  -12 }, // 'E'
  {   500,  10,  12,  12,    1,  -12 }, // 'F'
  {   515,  12,  12,  14,    1,  -12 }, // 'G'
  {   533,  12,  12,  15,    1,  -12 }, // 'H'
  {   551,   5,  12,   8,    1,  -12 }, // 'I'
  {   559,   7,  16,   8,   -1,  -12 }, // 'J'
  {   573,  13,  12,  14,    1,  -12 }, // 'K'
  {   593,  10,  12,  12,    1,  -12 }, // 'L'
  {   608,  16,  12,  18,    1,  -12 }, // 'M'
  {   632,  12,  12,  15,    1,  -12 }, // 'N'
  {   650,  14,  12,  16,    1,  -12 }, // 'O'
  {   671,  12,  12,  14,    1,  -12 }, // 'P'
  {   689,  14,  17,  16,    1,  -12 }, // 'Q'
  {   719,  13,  12,  14,    1,  -12 }, // 'R'
  {   739,  12,  12,  13,    0,  -12 }, // 'S'
  {   757,  11,  12,  12,    0,  -12 }, // 'T'
  {   774,  12,  12,  15,    1,  -12 }, // 'U'
  {   792,  13,  12,  13,    0,  -12 }, // 'V'
  {   812,  18,  12,  18,    0,  -12 }, // 'W'
  {   839,  13,  12,  13,    0,  -12 }, // 'X'
  {   859,  12,  12,  12,    0,  -12 }, // 'Y'
  {   877,  12,  12,  13,    0,  -12 }, // 'Z'
  {   895,   6,  15,   8,    1,  -13 }, // '['
  {   907,   9,  12,  10,    0,  -12 }, // '\'
  {   921,   5,  15,   8,    1,  -13 }, // ']'
  {   931,   7,   6,   8,    0,  -12 }, // '^'
  {   937,   9,   2,  13,    2,    1 }, // '_'
  {   940,   6,   4,   6,    0,  -12 }, // '`'
  {   943,  11,  10,  13,    1,  -10 }, // 'a'
  {   957,  11,  13,  13,    1,  -13 }, // 'b'
  {   975,  10,  10,  12,    1,  -10 }, // 'c'
  {   988,  11,  13,  13,    1,  -13 }, // 'd'
  {  1006,  10,  10,  12,    1,  -10 }, // 'e'
  {  1019,  11,  14,  10,    0,  -14 }, // 'f'
  {  1039,  11,  14,  13,    1,  -10 }, // 'g'
  {  1059,  11,  15,  13,    1,  -13 }, // 'h'
  {  1080,   5,  13,   7,    1,  -13 }, // 'i'
  {  1089,   7,  17,   7,   -1,  -13 }, // 'j'
  {  1104,  11,  13,  12,    1,  -13 }, // 'k'
  {  1122,   4,  14,   7,    1,  -14 }, // 'l'
  {  1129,  16,  12,  18,    1,  -10 }, // 'm'
  {  1153,  11,  12,  13,    1,  -10 }, // 'n'
  {  1170,  11,  10,  13,    1,  -10 }, // 'o'
  {  1184,  11,  14,  13,    1,  -10 }, // 'p'
  {  1204,  11,  14,  13,    1,  -10 }, // 'q'
  {  1224,  10,  10,  11,    1,  -10 }, // 'r'
  {  1237,  11,  10,  11,    0,  -10 }, // 's'
  {  1251,   9,  13,   9,    0,  -13 }, // 't'
  {  1266,  11,  10,  13,    1,  -10 }, // 'u'
  {  1280,  11,  10,  11,    0,  -10 }, // 'v'
  {  1294,  15,  10,  16,    0,  -10 }, // 'w'
  {  1313,  11,  10,  11,    0,  -10 }, // 'x'
  {  1327,  11,  14,  11,    0,  -10 }, // 'y'
  {  1347,   9,  10,  11,    1,  -10 }, // 'z'
  {  1359,   7,  15,   9,    1,  -13 }, // '{'
  {  1373,   4,  15,   7,    1,  -13 }, // '|'
  {  1381,   7,  15,   9,    1,  -13 } // '}'
};
const GFXfont Aclonica_Regular_16 PROGMEM = {
(uint8_t  *)Aclonica_Regular_16Bitmaps,(GFXglyph *)Aclonica_Regular_16Glyphs,0x20, 0x7E, 19};

La font Tiny3x3a est définie ici est vraiment minuscule (et moche :)) ) et ressemble à cela:

J4l13n:
et dans l'exemple correspondant :

{49, 3, 3, 4, 0, -2},   // 0x41 'A'

il y a 49 = index , 3= largeur, 3= hauteur, 4 = xAdvance,3 = xOffset, -2 = yOffset .
Je ne comprend pas comment on peut allumer autant de led avec seulement 6 variables.

la première valeur est l'Index dans le tableau des bitmap. c'est là que sont les pixels. Ici on nous dit que le caractère est un bitmap de 3 de large sur 4 de haut -> donc 12 pixels à allumer.
Comme vous avez 1 bit par pixel, et qu'on ne mélange pas les octets, il faut 2 octets pour les 12 bits (donc 16 bits, 12 pour le bitmap et 4 pas utilisés). C'est pour cela que si vous regardez le caractère suivant, son index de départ sera 51 soit 2 octets plus loin dans la table des bitmaps.

Maintenant, si vous allez voir l'entrée 49 du tableau des bitmaps

 const uint8_t Tiny3x3a2pt7bBitmaps[] PROGMEM = {
    0xC0, 0xB4, 0xBF, 0x80, 0x6B, 0x00, 0xDD, 0x80, 0x59, 0x80, 0x80, 0x64,
    0x98, 0xF0, 0x5D, 0x00, 0xC0, 0xE0, 0x80, 0x2A, 0x00, 0x55, 0x00, 0x94,
    0xC9, 0x80, 0xEF, 0x80, 0xBC, 0x80, 0x6B, 0x00, 0x9F, 0x80, 0xE4, 0x80,
    0x7F, 0x00, 0xFC, 0x80, 0xA0, 0x58, 0x64, 0xE3, 0x80, 0x98, 0xD8, 0xD8,
    0x80, [color=red]0x5E, 0x80[/color], 0xDF, 0x80, 0x71, 0x80, 0xD7, 0x00, 0xFB, 0x80, 0xFA,
    0x00, 0xD7, 0x80, 0xBE, 0x80, 0xE0, 0x27, 0x00, 0xBA, 0x80, 0x93, 0x80,
    0xFE, 0x80, 0xF6, 0x80, 0xF7, 0x80, 0xFE, 0x00, 0xF7, 0x00, 0xDE, 0x80,
    0x6B, 0x00, 0xE9, 0x00, 0xB7, 0x80, 0xB5, 0x00, 0xBF, 0x80, 0xAA, 0x80,
    0xA9, 0x00, 0xEB, 0x80, 0xEC, 0x88, 0x80, 0xDC, 0x54, 0xE0, 0x90, 0x70,
    0xBC, 0xF0, 0x7C, 0xB0, 0x68, 0xFC, 0xBC, 0xC0, 0x58, 0x9A, 0x80, 0xA4,
    0xDC, 0xD4, 0xF0, 0xF8, 0xF4, 0xE0, 0x60, 0x59, 0x80, 0xBC, 0xA8, 0xEC,
    0xF0, 0xAC, 0x80, 0x90, 0x79, 0x80, 0xF0, 0xCF, 0x00, 0x78};

on trouve [color=red]0x5E, 0x80[/color]

si vous représentez cela en mémoire on a ces valeurs:

en mettant un point allumé pour les 1 et éteint pour les 0 on a:

en sélectionnant maintenant 4 groupes de 3 pixels consécutifs pour former notre bitmap

enfin en les superposant ça donne ça

4.png

magique, on retrouve bien le symbole A de la police :slight_smile:

EDIT: petite erreur dans mon explication ci dessus c'est bien 3x3 pas 3x4 donc c'est juste la ligne blanche en dessous du caractère qu'il ne faut pas prendre en compte dans le bitmap

4.png

Merci beaucoup à vous, ça commence à vraiment être plus clair,

Donc :

  1. je créé un
const uint8_t Tiny3x3a2pt7bBitmaps[] PROGMEM = {
    0xC0, 0xB4, 0xBF, //
    0x80, 0x6B, 0x00, // 1 chiffre 
    0xDD, 0x80, 0x59,// 
    0x80, 0x80, 0x64, // 
    0x98, 0xF0, 0x5D, //
    ......................... 
    0x80, 0x2A, 0x00, // 1 autre chiffre
    0x55, 0x00, 0x6B,}
  1. puis
const GFXglyph SymbolMono18pt7bGlyphs[] PROGMEM = {
  //Index,  W, H,xAdv,dX, dY
  {     0, 3,5, 21, 3,-19}, // le chiffre 0 
  {    14, 3,5, ]21, 3,-18}, //le chiffre 1 
  {    28, 3,5,21, 3,-18}, // le chiffre 2
//Etc.
  1. et je l’affiche avec
matrix.setTextColor(255,0,0);
  matrix.print('1');

C’est ça ?

Par contre à que font les 3 derniere variable ? { 28, 3,5,21, 3,-18} elle corresponde à quoi ?

merci

hum - si votre premier chiffre c'est

   0xC0, 0xB4, 0xBF, //
    0x80, 0x6B, 0x00, // 1 chiffre 
    0xDD, 0x80, 0x59,// 
    0x80, 0x80, 0x64, // 
    0x98, 0xF0, 0x5D, //

ça fait 15 octets

donc dans votre tableau de glyphs

{   0, 3, 5, 21, 3,-19},  // le chiffre 0 
{  [color=blue]14[/color], 3, 5, [color=red][b]][/b][/color]21, 3,-18}, // le chiffre 1

vous ne pouvez pas dire que le second bitmap commence à 14. il doit commencer à 15 (de 0 à 14 pour les 15 premiers octets, ça fait que le suivant est à 15)

l y a aussi un caractère louche ] dans votre chiffre 1

pour les autres valeurs, il faut lire le lien que j'ai donné dans la réponse #1, je ne l'avais pas mis pour décorer.... ::slight_smile: :slightly_frowning_face:
--> plus de détails ici

The next value is the xAdvance value. When using these fonts with the print() or println() functions this tells the software how much space to put between each character horizontally. Because this is a fixed space font we are using a constant value of 21. Although our actual glyph is only 16 pixels wide this gives two extra pixels on one side and three on the other. You need that blank space for readability. The way we have implemented things so that it automatically switches back and forth between our symbol font and the standard mono 18 font, we will not be able to use print or println. Instead we will use a custom drawChar function to draw individual characters.
The final two values are called dX and dY which are used to position the glyph within the cell. As you can see the dX value varies between 2-4. The dY value is the distance from the baseline of the character to the top of the glyph. So for example the large test square starts 19 pixels up from the baseline of the character cell. However the "Space Bar" glyph is only 2 pixels above the baseline. You will have to play around with these values to get the glyph centered horizontally and vertically the way that you want it. The sample sketch we provide lets you visualize that position and you can make the appropriate adjustments.

J-M-L:
l y a aussi un caractère louche ] dans votre chiffre 1

j'ai voulu les mettre en rouge au début, mais les avoir mis entre les balises codes les supprimes.. j'ai oublier ce crochet...

pour le second bitmap j'étais pourtant bien parti de 0 ... :smiley:

Ok pour la 3ème variable 21 c'est l'espacement entre les lettres horizontalement du coup je vais mettre 4 ?(3 de la lettre +1 vide pour espacer )

les 2 dernieres sont la pour centré ? par exemple le - du 6 ?

const uint8_t fontpersoBitmaps[] PROGMEM = {
    0xC0, 0xB4, 0xBF, 0x80, 0x59, 0x80, 0xBC, 0xA8, 0xEC,
     ................................
    0xF0, 0xAC, 0x80, 0x90, 0x79, 0x80, 0xF0, 0xCF, 0x00, 0x78};


const GFXglyph fontpersoGlyphs[] PROGMEM = {
    {0, 0, 0, 4, 0, 1},     // 0x20 '0'
    {0, 1, 2, 3, 1, -2},    // 0x21 '1'
    {1, 3, 2, 4, 0, -2},    // 0x22 '2'
    {2, 3, 3, 4, 0, -2},    // 0x23 '3'
    {4, 3, 3, 4, 0, -2},    // 0x24 '4'
    {6, 3, 3, 4, 0, -2},    // 0x25 '5'
    {8, 3, 3, 4, 0, -2},    // 0x26 '6'
}




const GFXfont fontperso PROGMEM = {(uint8_t *)fontpersoBitmaps,
                                       (GFXglyph *)fontpersoGlyphs, 0x20,
                                       0x7E, 4}


// pour afficher le 0
matrix.setTextColor(255,0,0);
  matrix.print(fontperso([0]);

faut essayer et voir ce que ça donne :slight_smile:

ça ne compile pas, mais ça tu t’y attendait :wink:

#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

#define PIN 7

Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(20, 8, PIN,
  NEO_MATRIX_TOP    + NEO_MATRIX_LEFT +
  NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG,
  NEO_GRB            + NEO_KHZ800);

const uint8_t fontpersoBitmaps[] PROGMEM = {
    0x5E, 0x80};


const GFXglyph fontpersoGlyphs[] PROGMEM = {
    {0, 4, 3, 4, 0, 1},     // 0x20 'A'
};




const GFXfont fontperso PROGMEM = {(uint8_t *)fontpersoBitmaps,
                                       (GFXglyph *)fontpersoGlyphs, 0x20,
                                       0x7E, 4};


void setup() {
  matrix.begin();
  matrix.setTextWrap(false);
  matrix.setBrightness(1);
  matrix.setTextColor(255,0,0);
  matrix.print(fontperso (0));      // .  erreur
  matrix.show();

}

void loop() {
  }

j’ai une erreur de syntaxe sur le matrix.print(fontperso (0));

Je ne vois pas ce que tu cherches à faire : matrix.print(fontperso (0));
Ça rime à quoi ?

fontperso est une structure et tu l'utilise comme une fonction, avec des parenthèses ? ? ?

vous définissez une police, donc les entrées sont associées avec la table ASCII --> pourquoi ne pas essayer avec un caractère

 matrix.print(" ");

hbachetti:
Je ne vois pas ce que tu cherches à faire : matrix.print(fontperso (0));
Ça rime à quoi ?

fontperso est une structure et tu l'utilise comme une fonction, avec des parenthèses ? ? ?

Je veut afficher la police que j'ai créé,

je pense avoir trouvé ma solution ici

@+