Protocole serie pour afficheur 20 caracteres 14 segments ?

International Français
1

Bonjour,

à la base j'ai trouvé :
https://github.com/tehniq3/VFD_FG209M2_2MAX6921/blob/master/README.md

d'apres ce que j'ai compris : il envoie une série de 20 bits pour la position du caractere + 20 bits pour le caractere qui est défini dans la table au début dans 2 max6921.
ce que j'ai réussi à faire : alterner des "phrases" de 20 caracteres max
est-il possible de définir une phrase plus longue et faire défiler les caracteres de droite à gauche ?
ou de se servir du moniteur série comme "entrée", cad écrire une phrase sur le moniteur série et envoyer pour qu'elle s'affiche "à la volée" ?

Merci
code adapté :

/*affiche message sur  vfd itron 20 carat 14 segments+ point+virgule
MAX6921 -> datasheet: http://datasheets.maximintegrated.com/en/ds/MAX6921-MAX6931.pdf
 original sketch from https://github.com/echox/arduino-test/blob/master/max6921.ino
current sketch by Nicu FLORICA (aka niq_ro)
https://github.com/tehniq3/VFD_FG209M2_2MAX6921
affichage de texte sans defilement
test ok
*/


int clk = 3;  // 6921 :  15
int load = 5; // 6921 :  16
int din = 4;    // 6921 :  27
int led = 13;
int blank = 7;    // 6921 : 13



//etoile
byte ics[20] =   { 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

byte zero[20] = { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1};

byte un[20] =  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0};

byte deux[20] =   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1};

byte trois[20] =  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1};

byte quatre[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0};

byte cinci[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1};

byte cinq[20]= { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1};

byte six[20] =  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1};

byte sept[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1};

byte huit[20] =   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1};

byte neuf[20] =  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1};
// alphabet majuscules
byte literaA[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1};

byte literaB[20] = { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1};

byte literaC[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1};

byte literaD[20] = { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1};

byte literaE[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1};

byte literaF[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1};

byte literaG[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1};

byte literaH[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0};

byte literaI[20] = { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1};

byte literaJ[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0};

byte literaK[20]=  { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0};

byte literaL[20]=  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0};

byte literaM[20]= { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0};

byte literaN[20]= { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0};

byte literaO[20]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1};

byte literaP[20]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1};

byte literaQ[20]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1};

byte literaR[20]= { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1};

byte literaS[20]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1};

byte literaT[20]=  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};

byte literaU[20]=  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0};

byte literaV[20]=  { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0};

byte literaW[20]=  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

byte literaX[20]=  { 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

byte literaY[20]=  { 1, 0, 1, 0, 0 , 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};


byte litezaZ[20]=  { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1};

//espace
byte gol[20] =  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

byte minus[20]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0};

byte plus[20]=  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0};
               
byte grad[20]=  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1};

byte arond[20]= { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1};

byte egal[20]=  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0};
int p;
int s;

// diff delais duree affichage
int delaiaf2 = 300;
int timeaf=700;  //

void setup() {
  pinMode(din, OUTPUT);
  pinMode(load, OUTPUT);
  pinMode(clk, OUTPUT);
  pinMode(led, OUTPUT);

  pinMode(blank, OUTPUT);
  digitalWrite(blank, HIGH);
  delay(50);
  //digitalWrite(blank, LOW);

  digitalWrite(clk, LOW);
  digitalWrite(load, LOW);
  digitalWrite(din, LOW);
}

void loop()
{
digitalWrite(blank, LOW);// display on
// le texte s'affiche en une fois pendant la duree timeaf
for(int k=0; k < timeaf; k++) {

affichcar0(19, ics);// position a gauche 1er caractere

affichcar0(18, ics); // etoile
affichcar0(17, ics);
affichcar0(16, gol); // espace
affichcar0(15, literaJ);  // 
affichcar0(14, literaO);
affichcar0(13, literaY);
affichcar0(12, literaE);
affichcar0(11, literaU);
affichcar0(10, literaX);  // 
affichcar0(9, gol);
affichcar0(8, literaN);
affichcar0(7, literaO);
affichcar0(6, literaE);
affichcar0(5, literaL);
affichcar0(4, gol);

affichcar0(2, ics);
affichcar0(1, ics);
affichcar0(0, ics);
/*
affichcar0(7, literaA); // position 7 caract A
affichcar0(6, literaD);
affichcar0(5, literaO);
affichcar0(4, literaR);
affichcar0(3, literaA);
affichcar0(2, literaB);
affichcar0(1, literaL);
affichcar0(0, literaE);
*/

}

//delay(500);
  digitalWrite(blank, HIGH);// display off
  delay(50); 
  
  // comme çà n'efface pas le buffer, on pourrait charger 
  // la nouvelle phrase dans le buffer display off
  // et remettre display on apres 
  // ou faire défiler une phrase plus longue


//delay(100);
//deleteline();
  
  // nouveau texte avec duree différente
  digitalWrite(blank, LOW);// display on
for(int k=0; k < delaiaf2; k++) {
affichcar0(19, literaM);  // position 19 
affichcar0(18, literaE);
affichcar0(17, literaI);
affichcar0(16, literaL);
affichcar0(15, literaL);
affichcar0(14, literaE);  // position 14 
affichcar0(13, literaU);
affichcar0(12, literaR);
affichcar0(11, literaS);
affichcar0(10, gol);
affichcar0(9, literaV);
affichcar0(8, literaO); // 
affichcar0(7, literaE);
affichcar0(6, literaU);
affichcar0(5, literaX);
affichcar0(4, gol);
affichcar0(3, deux);
affichcar0(2, zero);
affichcar0(1, deux);
affichcar0(0, trois);

}
  
  //delay(400);
  digitalWrite(blank, HIGH);// display off
  delay(20); 
  
}

// fonction affichage
void affichcar0 (byte placecar, byte caracter[20]) {
   // first put position of character
    for(int i=0;i<20;i++) {
    if (i == placecar) digitalWrite(din, 1);
    else  digitalWrite(din, 0);
     digitalWrite(clk, HIGH);
     digitalWrite(clk, LOW);
    }
 //   digitalWrite(clk, LOW);

// second put letter/character
  for(int i=19;i>=0;i--) {
     digitalWrite(din, caracter[i]); 
     digitalWrite(clk, HIGH);
     digitalWrite(clk, LOW);
    }
 //   digitalWrite(clk, LOW);

  // load the changes
    digitalWrite(load, HIGH);
    digitalWrite(load, LOW);
}

// fonction effacement ligne  remplir avec des espaces

void deleteline(){
  for(p=19; p>=0; p--);{
affichcar0(p, gol); }
}


// fonction affichage qui ajoute virgule au caractere
/*
void affichcar1 (byte placecar, byte caracter[20]) {
   // first put position of character
    for(int i=0;i<20;i++) {
    if (i == placecar) digitalWrite(din, 1);
    else  digitalWrite(din, 0);
     digitalWrite(clk, HIGH);
     digitalWrite(clk, LOW);
     digitalWrite(led, LOW);
    }

// second put letter/character
  for(int i=19;i>=0;i--) {
     if (i == 7) digitalWrite(din, 1);  // la virgule ?  
     else 
     digitalWrite(din, caracter[i]); 
     digitalWrite(clk, HIGH);
     digitalWrite(clk, LOW);
    }

  // load the changes
    digitalWrite(load, HIGH);
    digitalWrite(load, LOW);
    digitalWrite(led, HIGH);
}*/saisissez ou collez du code ici

Merci

new_vfdmg209a
new_vfdmg209a1024×576 130 KB

new_vfdjoynoel
new_vfdjoynoel1024×576 73.9 KB

2

Au survol de ton programme, je dirais que tu as bien compris.
Par contre non tu ne peux pas en soit envoyer une phrase plus longue, car en faite tu n'envois pas une phrase, mais les "patterns" à afficher position par position.
Donc si tu veux faire un défilement, c'est à toi de le faire.
Avec par exemple un tableau contenant les caractères à afficher et une variable t'indiquant quel est le premier caractère à afficher et afficher les 20 caractères suivant comme tu le fais actuellement.

3

Oui pour tout ça.

Cependant cela nécessiterait quelque modifications du code pour le rendre plus simple dans son utilisation et moins gourmand en mémoire.
Par exemple, actuellement chaque caractère est défini dans un tableau de 20 valeurs qui sont soit 0, soit 1 ce qui du point de vue de l'utilisation mémoire est très inefficace,
La ligne suivante utilise 20 octets pour stocker la description du caractère A

byte literaA[20] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1};

En l'écrivant autrement on pourrait n'utiliser que 4 octets

unsigned long literaA=0b00000000000001111111;

ou

unsigned long literaA = 0x007F;

Cela implique de modifier légèrement la fonction affichcar0() pour qu'elle prenne ce nombre et qu'elle teste les 20 bits utiles pour savoir si elle doit envoyer un 1 ou un 0.
Quelque chose comme ça

void affichcar0 (byte placecar, unsigned long caracter) {
   // first put position of character
    for(int i=0;i<20;i++) {
    if (i == placecar) digitalWrite(din, 1);
    else  digitalWrite(din, 0);
     digitalWrite(clk, HIGH);
     digitalWrite(clk, LOW);
    }
 //   digitalWrite(clk, LOW);

// second put letter/character
  unsigned long car = caracter;
  for(int i=19;i>=0;i--) {
     digitalWrite(din, caracter && 1? HIGH: LOW); 
     car >>= 1;
     digitalWrite(clk, HIGH);
     digitalWrite(clk, LOW);
    }
 //   digitalWrite(clk, LOW);

  // load the changes
    digitalWrite(load, HIGH);
    digitalWrite(load, LOW);
}

Ensuite, pour pouvoir afficher des phrases, il serait pratique de faire un tableau avec les lettres et les chiffres pour que l'on puisse facilement aller chercher la description des caractères à afficher dans ce tableau en utilisant le code ASCII des lettres de la phrase.

4

Tu pourrais t'inspirer du tableau pour afficheurs 14 segments qui est accessible par le lien suivant :

LED-Segment-ASCII/14-Segment/14-Segment-ASCII_BIN.txt at master · dmadison/LED-Segment-ASCII · GitHub

( Source : Segmented LED Display - ASCII Library )

5

bonjour
merci pour les infos, çà devient trop compliqué pour mon niveau, je vais me contenter de flasher le code de nicu florica qui me fera une horloge avec temperature ambiante

j'ai des tas d'autres vfd a tester, ayant trouvé une bonne source d'infos
VFD

merci

6

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.