20 réponses à ce sujet

[bypbop]

Bonjour je decouvre les matrices de led 8x8
j'arrive a faire defiler vers le haut ou le bas sans prb mais de droite à gauche cela pose problème.

sur X j'ai 1 2 3 1 5 6 7 0
et sur Y j'ai 0 1 2 3 4 5 6 7

J'ai compris un peu le principe avec les X et Y mais comment faire un scrolling vers la droite ou vers la gauche si les index ne se suivent pas.

#include <Sprite.h>  // Sprite before Matrix
#include <Matrix.h>

//                  DIN, CLK, LOAD, #chips
Matrix myLeds = Matrix(22, 26, 24, 1);


Sprite letter_A = Sprite(5, 7,
  
  B01110,
  B10001,
  B10001,
  B10001,
  B11111,
  B10001,
  B10001
);


void setup() {
Serial.begin(57600);  
}

void loop() {
myLeds.clear();
myLeds.setBrightness(4);

myLeds.write(0, 0, letter_A);
delay(1000);

}

sur la photo j'affiche un A en commençant à x=0 et Y=0


Cordialement,
bypbop

Image(s) jointe(s)

• 

[Mike118]

Bonjour,

Je ne sais pas comment fonctionne ta matrice de led 8*8 avec ton code mais je suis sur que si tu me donne un peu plus de détails, genre le code permettant d'allumer les led de coordonné 0*0 1*0 puis 0*1, je suis sur que je peux t'aider pour l'algorithmique du défilement ...

(Sinon le lien expliquant comment ça marche sur lequel tu t'es basé ça peut marcher pour moi aussi ^^ ) en tout cas bonne continuation et à bientôt !

[bypbop]

Bonjour Mike118,

Alors en fait j'affiche un A que j'ai codé en 5x7

En faisant ca :

Sprite letter_A = Sprite(5, 7,    B01110,  B10001,  B10001,  B10001,  B11111,  B10001,  B10001);

et je l'affiche en faisant :

myLeds.write(0, 0, letter_A);

si je mets

myLeds.write(1, 0, letter_A);

le A s'affiche correctement (pas comme sur la photo)

mais le problème c'est que si je veux incrémenter ma position sur x en faisant +1 cela fonctionne sauf pour la dernière ligne qui a pour coordonnées 0.

1 2 3 4 5 6 7 0

Cordialement,
bypbop

[Black Templar]

mais le problème c'est que si je veux incrémenter ma position sur x en faisant +1 cela fonctionne sauf pour la dernière ligne qui a pour coordonnées 0.

1 2 3 4 5 6 7 0

Si tu veux faire défiler à l'horizontale à l'infinie, tu veux faire :

int positionx = 1;
while(1) {
  myLed.write(positionx, 1, monSprite);
  positionx = (positionx+1)%8
}

Comme ça, après 7, il revient à 0 (qui est la dernière position), puis 1, 2, etc.

[bypbop]

Merci Black

tu m'as mis sur la voie en fait qd on fait :

myLeds.write(positionx, 0, letter_A);

quand postionx = 0 il affiche le reste du A sur la colonne 1 2 3 4 et ensuite on repart à 1 donc ca fait bizarre sur la fin.

Pour test j'ai fait une simple ligne verticale comme cela c'est coherent :

void loop() { 
myLeds.clear(); 
myLeds.setBrightness(4);
myLeds.write(positionx, 0, HIGH);
myLeds.write(positionx, 1, HIGH); 
myLeds.write(positionx, 2, HIGH);
myLeds.write(positionx, 3, HIGH);
myLeds.write(positionx, 4, HIGH);
myLeds.write(positionx, 5, HIGH);
myLeds.write(positionx, 6, HIGH);
myLeds.write(positionx, 7, HIGH);
positionx = (positionx+1)%8;
delay(150);
 
}

donc peut etre voir la taille du sprite en fonction de sa position ...

Cordialement,
bypbop

[Mike118]

si tu fais ça :

#include <Sprite.h>  // Sprite before Matrix
#include <Matrix.h>

//                  DIN, CLK, LOAD, #chips
Matrix myLeds = Matrix(22, 26, 24, 1);


Sprite HELLOWORLD = Sprite(76,7 ,
  
  B1000100111110010000001000000111110000100000100111110011111001000000111100000,
  B1000100100000010000001000000100010000100000100100010010001001000000100010000,
  B1000100100000010000001000000100010000100100100100010010001001000000100010000,
  B1111100111110010000001000000100010000100100100100010011110001000000100010000,
  B1000100100000010000001000000100010000101010100100010010001001000000100010000,
  B1000100100000010000001000000100010000110001100100010010001001000000100010000,
  B1000100111110011111001111100111110000100000100111110010001001111100111100000,
);


void setup() {
Serial.begin(57600);  
}

void loop() {
int positionx = 1;
myLeds.clear();
myLeds.setBrightness(4);

while(1) {
  myLed.write(positionx, 1, HELLOWORLD);
  positionx = (positionx-1)%76;
  delay(1000);

}


}

ça donne quoi ?

[bypbop]

Bonjour Mike118,

Cela ne compile pas chez moi il doit y avoir une erreur dans le sprite je pense.

Cordialement,
bypbop

[Mike118]

Bonjour Mike118,

Cela ne compile pas chez moi il doit y avoir une erreur dans le sprite je pense.

Cordialement,
bypbop

En effet j'ai mis une virgule en trop dans le sprite ...

essaye ceci :

#include <Sprite.h>  // Sprite before Matrix
#include <Matrix.h>

//                  DIN, CLK, LOAD, #chips
Matrix myLeds = Matrix(22, 26, 24, 1);


Sprite HELLOWORLD = Sprite(76,7 ,
  
  B1000100111110010000001000000111110000100000100111110011111001000000111100000,
  B1000100100000010000001000000100010000100000100100010010001001000000100010000,
  B1000100100000010000001000000100010000100100100100010010001001000000100010000,
  B1111100111110010000001000000100010000100100100100010011110001000000100010000,
  B1000100100000010000001000000100010000101010100100010010001001000000100010000,
  B1000100100000010000001000000100010000110001100100010010001001000000100010000,
  B1000100111110011111001111100111110000100000100111110010001001111100111100000
);


void setup() {
Serial.begin(57600);  
}

void loop() {
int positionx = 1;
myLeds.clear();
myLeds.setBrightness(4);

while(1) {
  myLed.write(positionx, 1, HELLOWORLD);
  positionx = (positionx-1)%76;
  delay(1000);

}


}

PS : je n'ai pas de arduino ni installé le logiciel simulant l'arduino donc je dis bien " d'essayer " ^^ Pas que ceci est le bon code =) En tout cas l'algorithmique de ce code me parait bonne, reste à voir si il y a pas encore des petites erreurs de syntaxes cachées ^^

[Black Templar]

int positionx = 1;

while(1) {
  myLed.write(positionx, 1, HELLOWORLD);
  positionx = (positionx-1)%76;
  delay(1000);

}

Hum... ça me semble bizarre tout de même.
Son afficheur n'a que 8 colonnes. La première à pour index 1, on incrémente de 1 pour les suivante.
L'exception est pour la dernière colonne qui est d'index 0.
Si ton sprite dépasse de l'afficheur, la partie coupé est affiché au début (c'est cylindrique, voir torique)

Donc déjà, je suis curieux de savoir ce qui va s'afficher, sachant que ton sprite est 10 fois plus grand que l'afficheur ^^
Ensuite, dans ton code, tu commences l'affichage à l'index 0, c'est à dire à la dernière colonne.
Ton modulo 76, est aussi étrange car l'afficheur n'a que 8 index ^^

Je suis curieux de voir ce que ça donne ^^



EDIT : @bypbop : si ça ne compile pas, tu peux poster les erreurs ?

[bypbop]

wep je l'avais vu mais ca compile pas toujours.

Cordialement,
bypbop

[bypbop]

Apparemment il prend pas le sprite :

sketch_mar28a:10: error: 'B1000100111110010000001000000111110000100000100111110011111001000000111100000' was not declared in this scope
sketch_mar28a:11: error: 'B1000100100000010000001000000100010000100000100100010010001001000000100010000' was not declared in this scope
sketch_mar28a:12: error: 'B1000100100000010000001000000100010000100100100100010010001001000000100010000' was not declared in this scope
sketch_mar28a:13: error: 'B1111100111110010000001000000100010000100100100100010011110001000000100010000' was not declared in this scope
sketch_mar28a:14: error: 'B1000100100000010000001000000100010000101010100100010010001001000000100010000' was not declared in this scope
sketch_mar28a:15: error: 'B1000100100000010000001000000100010000110001100100010010001001000000100010000' was not declared in this scope
sketch_mar28a:16: error: 'B1000100111110011111001111100111110000100000100111110010001001111100111100000' was not declared in this scope

Cordialement,
bypbop

[Black Templar]

Ahhhh oui. En effet.
Un nombre écrit de cette manière (en binaire) ne peut pas faire plus d'un octet, soit 8bits.
Donc ton sprite ne peut pas être plus large que de 8 colonnes.

[bypbop]

Ok Ok donc comment faire si on veut afficher par exemple sur le module 8x8

A et B à la suite et non pas A puis B

Sprite letter_A = Sprite(5, 7,

B01110,
B10001,
B10001,
B10001,
B11111,
B10001,
B10001
);

Sprite letter_B = Sprite(5, 7,

B01110,
B10001,
B10001,
B10001,
B11111,
B10001,
B10001
);


Peut on additionner les sprites et faire defiler sur les 8 colonnes ?

[Mike118]

Ahhhh oui. En effet.
Un nombre écrit de cette manière (en binaire) ne peut pas faire plus d'un octet, soit 8bits.
Donc ton sprite ne peut pas être plus large que de 8 colonnes.

ah oui en effet ... j'ai oublier ce détail plus qu'important x)
Ensuite je ne pensais pas que si le sprite dépasse de l'afficheur, la partie coupé serait affiché au début j'espérait justement que ça n'afficherais pas ce qui dépasse x)

Hors ça ne peut pas dépasser x) Ainsi le problème est résolu x)

[bypbop]

J'ai regardé pas mal d'exemple de scrolling j'ai une petite piste.
Je vais travailler sur cela cette semaine.

#define A {B01110, B10001, B10001, B10001, B11111, B10001, B10001}  
#define B {B01110, B10001, B10001, B10001, B11111, B10001, B10001}  
byte Message[2][8]={A,B};

J'ai mis la mm valeur dans A et B juste pour mes test.

La cela compile reste à voir comment afficher.

Cordialement,
bypbop

[Mike118]

J'ai regardé pas mal d'exemple de scrolling j'ai une petite piste.
Je vais travailler sur cela cette semaine.

#define A {B01110, B10001, B10001, B10001, B11111, B10001, B10001}  
#define B {B01110, B10001, B10001, B10001, B11111, B10001, B10001}  
byte Message[2][8]={A,B};

J'ai mis la mm valeur dans A et B juste pour mes test.

La cela compile reste à voir comment afficher.

Cordialement,
bypbop

Du coup un truc comme

#include <Sprite.h>  // Sprite before Matrix
#include <Matrix.h>

#define A {B01110, B10001, B10001, B10001, B11111, B10001, B10001}  
#define B {B11110, B10001, B10001, B11111, B10001, B10001, B11110}  


byte Message[2][8]={A,B};

//                  DIN, CLK, LOAD, #chips
Matrix myLeds = Matrix(22, 26, 24, 1);


void setup() {
Serial.begin(57600);  
}

void loop() {
myLeds.clear();
myLeds.setBrightness(4);
int i=1;
while(1){
myLeds.write(1, 0,Message[i][8] );
delay(1000);
i++;
i=i%2 +1;
}

}

ça te fait peut être du texte clignotant ^^

Mais bon je garantis pas x) en plus il y a peut être un problème d'indice ... Sous arduino vous commencez souvent à compter à partir de 1 et pas à 0 visiblement mais il semble que c'est pas vrai pour tout x)

[bypbop]

Bonjour à tous

@BlackTemplar : Alors le dernier code n'affiche rien

Je travaille tjrs dessus.


Cordialement,
bypbop

[R1D1]

Mais bon je garantis pas x) en plus il y a peut être un problème d'indice ... Sous arduino vous commencez souvent à compter à partir de 1 et pas à 0 visiblement mais il semble que c'est pas vrai pour tout x)

Ah bon ? C'est du C++, donc l'indexation commence à zéro ... Je serais curieux de voir d'où tu sors ça ? ^^

[Mike118]

Ah bon ? C'est du C++, donc l'indexation commence à zéro ... Je serais curieux de voir d'où tu sors ça ? ^^

C'est une remarque par rapport aux résultats qu'il obtient avec sa matrice de led et au problème de son A affiché bizarrement sur la photo qu'il a posté ^^ je sors ça de nul part ailleurs
On voit que la première colonne affiche ce qui est à l'indexe 1 et pas à 0 et que la 8 ème colone affiche ce qui est présent à l'indexe 0 ... ( Le "souvent" était peut être un peu de trop je conçois ^^ mais c'était uniquement une figure de style pour souligner l'ironie =) )

Par contre je pensais que c'était du C# et pas du C++ Me trompe-je ? ( Malgré ce que peux en dire wikipédia qui n'a pas toujours raison non plus ^^ )

[Black Templar]

Par contre je pensais que c'était du C# et pas du C++ Me trompe-je ? ( Malgré ce que peux en dire wikipédia qui n'a pas toujours raison non plus ^^ )

Non non, Arduino, c'est bien du C++ ! (avec un compilateur custom qui ne prend pas en charge certaine choses comme les opérateurs new et delete par exemple).
Le C# ça tourne sur une machine virtuelle, donc impossible à faire tourner sous arduino.

D'ailleurs, je me demande comment marche les cartes qui peuvent être programmé en C#... Est-ce que le "ByteCode" (désolé, je ne connais pas l'appellation pour C#) est lui-même recompilé en fonction du µC ?