Affichage 16 Segments

Bonjour à tous,

J’ai besoin de vos lumières concernant la gestion des afficheurs 16 segments. Je doit utiliser plusieurs de ces petites bébêtes en même temps. Pour cela j’utilise ce driver de matrice :

HT16k33

qui me permet de cabler 1:1 mes 16 segments (trop bien).

Pour avoir un truc propre j’ai trouver une table Ascii bien pratique qui référence chaque caractère ASCII et d’un point de vue binaire les segments à allumé ou éteindre (pour peu qu’on utilise le même ordre de câblage) :
librairie 16 segments

Alors le soucis c’est que les opération binaires j’ai beaucoup de mal et je ne voit pas la façon de procéder pour récupérer le code binaire correspondant à un caractère ASCII du tableau.

Ex: je souhaite afficher la lettre “C” qui dans le tableau est codé 0b00000000011110011.

const PROGMEM uint32_t SixteenSegmentASCII[96] = 
{
  0b00000000000000000, /* (space) */
  0b10000000000001100, /* ! */
  0b00000001000000100, /* " */
  0b01010101000111100, /* # */
  0b01010101010111011, /* $ */
  0b01110111010011001, /* % */
  0b01001001101110001, /* & */
  0b00000001000000000, /* ' */
  0b00001010000000000, /* ( */
  0b00100000100000000, /* ) */
  0b01111111100000000, /* * */
  0b01010101000000000, /* + */
  0b00100000000000000, /* , */
  0b01000100000000000, /* - */
  0b10000000000000000, /* . */
  0b00100010000000000, /* / */
  0b00100010011111111, /* 0 */
  0b00000010000001100, /* 1 */
  0b01000100001110111, /* 2 */
  0b00000100000111111, /* 3 */
  0b01000100010001100, /* 4 */
  0b01001000010110011, /* 5 */
  0b01000100011111011, /* 6 */
  0b00000000000001111, /* 7 */
  0b01000100011111111, /* 8 */
  0b01000100010111111, /* 9 */
  0b00010001000000000, /* : */
  0b00100001000000000, /* ; */
  0b01001010000000000, /* < */
  0b01000100000110000, /* = */
  0b00100100100000000, /* > */
  0b10010100000000111, /* ? */
  0b00000101011110111, /* @ */
  0b01000100011001111, /* A */
  0b00010101000111111, /* B */
  0b00000000011110011, /* C */
  0b00010001000111111, /* D */
  0b01000000011110011, /* E */
  0b01000000011000011, /* F */
  0b00000100011111011, /* G */
  0b01000100011001100, /* H */
  0b00010001000110011, /* I */
  0b00000000001111100, /* J */
  0b01001010011000000, /* K */
  0b00000000011110000, /* L */
  0b00000010111001100, /* M */
  0b00001000111001100, /* N */
  0b00000000011111111, /* O */
  0b01000100011000111, /* P */
  0b00001000011111111, /* Q */
  0b01001100011000111, /* R */
  0b01000100010111011, /* S */
  0b00010001000000011, /* T */
  0b00000000011111100, /* U */
  0b00100010011000000, /* V */
  0b00101000011001100, /* W */
  0b00101010100000000, /* X */
  0b01000100010111100, /* Y */
  0b00100010000110011, /* Z */
  0b00010001000010010, /* [ */
  0b00001000100000000, /* \ */
  0b00010001000100001, /* ] */
  0b00101000000000000, /* ^ */
  0b00000000000110000, /* _ */
  0b00000000100000000, /* ` */
  0b01010000001110000, /* a */
  0b01010000011100000, /* b */
  0b01000000001100000, /* c */
  0b00010100000011100, /* d */
  0b01100000001100000, /* e */
  0b01010101000000010, /* f */
  0b01010001010100001, /* g */
  0b01010000011000000, /* h */
  0b00010000000000000, /* i */
  0b00010001001100000, /* j */
  0b00011011000000000, /* k */
  0b00000000011000000, /* l */
  0b01010100001001000, /* m */
  0b01010000001000000, /* n */
  0b01010000001100000, /* o */
  0b01000001011000001, /* p */
  0b01010001010000001, /* q */
  0b01000000001000000, /* r */
  0b01010000010100001, /* s */
  0b01000000011100000, /* t */
  0b00010000001100000, /* u */
  0b00100000001000000, /* v */
  0b00101000001001000, /* w */
  0b00101010100000000, /* x */
  0b00000101000011100, /* y */
  0b01100000000100000, /* z */
  0b01010001000010010, /* { */
  0b00010001000000000, /* | */
  0b00010101000100001, /* } */
  0b01100110000000000, /* ~ */
  0b00000000000000000, /* (del) */
};

Y’a t’il une opération sur les bytes exploitable tel qu’elle ou faut il que je réécrive la table d’une façon différente pour pouvoir y accéder ?

merci de votre aide

Je ne connais pas ces afficheurs, mais 16 segments et 16 bits, je dirais un bit par segment...

En comparant les lettres tu dois pouvoir trouver quel bit correspond à quel segment. Par exemple le C et le L. Le E et le F. Le B et le O. Etc

Ou alors tu écris un code qui envoie les codes 0, 2, 4, 8, 16, 32, etc et tu regardes quels segments sont allumés à chaque fois.

Désolé j’ai mal lu ta question. Tu cherches à passer de ‘C’ au code correspondant.

Si tu as ton caractère dans un char appelé ‘c’, le code de trouve dans la case c-32 du tableau SixteenSegmentASCII, qui lui même se trouve en PROGMEM.

Donc tu vérifies d’abord que ton caractère n’est pas inférieur à 32. Ensuite tu vas lire les 4 octets de ta valeur au bon endroit dans la progmem et tu les assembles

int k=c-32;
byte octet1 =  pgm_read_byte_near(SixteenSegmentASCII + k);
byte octet2 =  pgm_read_byte_near(SixteenSegmentASCII + k+1);
byte octet3 =  pgm_read_byte_near(SixteenSegmentASCII + k+2);
byte octet4 =  pgm_read_byte_near(SixteenSegmentASCII + k+3);
uint32_t valeur = (((octet1 <<8) + octet2) <<8 + octet3) <<8 + octet4 ;

Écrit sur mon portable, pas vérifié ni testé…

bonsoir et merci pour ta réponse rapide.

je viens de me rendre compte que ce tableau reprend la table ASCII classique, dans l'ordre mais amputé des 32 premier symboles ...
Donc en utilisant les char et en retirant 32 je devrais pouvoir faire correspondre un caractère ASCII avec le binaire associé qui va bien.

Merci pour ton aide

Bonjour,
dans le tableau, il y a 17 segments ...

Bonjour trimarco232

trimarco232:
Bonjour,
dans le tableau, il y a 17 segments …

16 segments + le point décimal

Cordialement,
bidouilleelec

En effet, je n'avais pas remarqué (sur mon portable), mais il y a aussi le point :