Discussion :

[f-leb]

J'ai encore aussi un module 1088AS monté sur un Max7219 (jamais utilisé)... A expérimenter ultérieurement.

Au niveau de la gestion du timing dans le code ce serait plus simple puisque le multiplexage est géré par le Max7219.

Conclusion, faire attention à la délimitation des blocs avec les accolades {...}. Un ctrl+T dans l'ide Arduino reformate le code et améliore la lisibilité :

code beurrk :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void setPattern(int pattern)
{ for (int i = 0; i < 8; i++)
{ for (int j = 0; j < 8; j++) LEDs[i][j] = patterns[ pattern][j][i];
}
}

Après un ctrl+T, c'est beaucoup mieux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void setPattern(int pattern) {
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) LEDs[i][j] = patterns[pattern][j][i];
  }
}

Et attention au point-virgule qui marque une fin d'instruction.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while ((millis() - start) <= interval); { ... }

le ; étant à la fin du while, le bloc { ... } n'est exécuté qu'une fois en sortie de la boucle while puisque ce bloc est une nouvelle instruction.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while ((millis() - start) <= interval) { ... }

Le bloc { ... } fait partie de l'instruction while, et est exécuté à chaque passage dans la boucle tant que la condition est vérifiée.

Encore merci et à bientôt...en essayant de ne pas abuser de votre disponibilité.

Pas de souci, quand tu veux, il y a toujours des membres qui trainent par ici pour aider ! Et pense à cliquer sur le bouton [Résolu] en bas de la page si tu penses en avoir fini avec ce code. À bientôt

[nicrolfi]

Bonsoir, grand merci pour ces conseils avisés.
J'essaie maintenant de regrouper des lettres dans array2D, pour ensuite faire défiler un mot (scrolling).
Je n'arrive pas à faire cela avec concat...
Mais ne trouve pas d'autre solution non plus.
Une piste?
Merci d'avance.
Roland

[nicrolfi]

Bonsoir,
Je crois, en me relisant, que je ne suis pas assez précis.
Dans mon code, j'ai un tableau qui est la lettre E (dim 8*8) et un Tableau qui est J (dim 8*8).
Je voudrais en faire un tableau JE qui fait bien sûr 8*16 comme dimension...
Cela avait l'air facile avec concat....mais....
Voilà.
Merci
A+
Roland

[nicrolfi]

Bonjour et bonne semaine...
La nuit porte conseil, j'ai trouvé une solution:
Je crée le 3ème vecteur et par boucle, j'y inscris les valeurs des 2 premiers vecteurs.
J'ai fais un petit essai hors code principal et cela marche.
Heu-reux!
Autres questions:
Quel est le type de valeurs engendrées par cette partie de code ?
Puis-je traiter Heart comment un vecteur?:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#define Heart {{0, 1, 0, 0, 0, 1, 0, 0}, \
{1, 0, 1, 0, 1, 0, 1, 0}, \
{1, 0, 0, 1, 0, 0, 1, 0}, \
{0, 1, 0, 0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 1, 0, 0, 0}, \
{0, 0, 0, 1, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0} \
}

Merci d'avance

Roland

[Jay M]

Quel est le type de valeurs engendrées par cette partie de code ?

c'est un tableau à 2 dimension de 8x8 cases avec une valeur numérique

comme c'est un define, le mot clé Heart sera remplacé par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
{{0, 1, 0, 0, 0, 1, 0, 0}, \
{1, 0, 1, 0, 1, 0, 1, 0}, \
{1, 0, 0, 1, 0, 0, 1, 0}, \
{0, 1, 0, 0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 1, 0, 0, 0}, \
{0, 0, 0, 1, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0, 0, 0, 0} \
}

donc si vous écrivez

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
const byte coeur[8]8] = Heart;

alors vous avez un tableau 2D de bytes.

mais si vous écrivez

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
const double coeur[8]8] = Heart;

alors c'est un tableau de nombres décimaux double précision et les 1 et 0 sont convertis implicitement.


Mais tout ce qui correspond au format du define peut fonctionner, vous pourriez avoir une structure initialisée ainsi....

[nicrolfi]

Grand merci pour votre réponse, je vais pouvoir encore avancer un peu dans mon projet...
A bientôt
Roland

[f-leb]

Bonsoir,

Pour faire du scrolling de droite à gauche, pixel par pixel, le pattern est plus compliqué à calculer à coups de division entière et de modulo...

La boucle loop() devient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void loop() {
  for (int decalage = 0; decalage < 8*(3-1); decalage++) { // 3 symboles, on décale 2x8 fois pour que le dernier symbole reste sur la matrice
    clearArray();
    setPattern(decalage);
    unsigned long start = millis();
    while ((millis() - start) <= interval) {
      updateDisplay();
      delay(1);
    }
  }

et la fonction setPattern() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void setPattern(int decalage) {
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) {
      int colIndex = (j + decalage) % 8;  // modulo 8
      int patternIndex = (decalage + j) / 8;  // division entière par 8
      LEDs[i][j] = patterns[patternIndex][i][colIndex];
    }
  }

Je n'ai pas testé donc il y aura peut-être des corrections à faire...

[nicrolfi]

Bonsoir et grand merci, je vais regarder cela de près demain...
Je suis étonné du peu d'instructions qu'il y a à modifier...
J'avais commencé à le faire à ma manière et suis tombé sur un os (encore!)
J'ai fait un code pour tester un 'concat" de vecteurs 2d (afin de mettre les icones à la queue leu leu...)
Le voici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#define E {{1, 1, 1, 1, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 6, 0, 0, 0}, \
    {1, 1, 1, 0, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 1, 1, 1, 1, 0, 0, 9}\
  }
#define J {{1,1,1,1,1,0,0,0},\
    {0,0,0,0,1,0,0,0},\
    {0,0,0,0,1,0,0,0},\
    {0,0,7,7,7,7,0,0},\
    {1,1,0,0,1,0,0,0},\
    {1,0,0,0,1,0,0,0},\
    {1,0,0,0,1,0,0,0},\
    {0,1,1,1,0,0,0,0}\
  }
const byte E1 [8][8] = E;
const byte J1 [8][8] = J;
byte J1E1 [8][16] = {};
 
void setup() {
 
  Serial.begin(9600);
J1E1[3][3] = 8;                                                                                                                                                           
  /*{{ for (int i = 0; i < 8; i++)
      { for (int m = 0; m < 8; i++)
        { J1E1[i][m] = J1[i][m];
        }
      }
    }
    
    { for (int j = 0; j < 8; j++)
      { for (int n = 0; n < 8; n++)
 
        { J1E1[j][n+8] = E1[j][n];
        }
      }
    }
  }
*/
  }
 
 
 
void loop()
 
{
 
  Serial.print("Donnee");
 
  Serial.print(J1E1[3][3]);
  delay(1000);
 
}

Pas de message lors de la compilation mais rien ne vient sur le moniteur série....(même pas "Donnée")
Si je bypasse les lignes 27 à 42(comme ci-dessus), alors j'obtiens quelque chose onnée0Donnée0...
Je me demande si les lignes 27 à 42 sont à la bonne place....
C'est comme si on tournait en rond dans ces lignes sans jamais passer à Loop...
Une idée?
Merci Bonne nuit.
Roland

[edgarjacobs]

Hello,

Ligne 28, i++ ??

C'est le débordement assuré.

[nicrolfi]

Bonjour,
Pour EdgarJacobs:
Merci beaucoup pour cette réponse.
Cela marche effectivement mieux (ça marche quoi!).
Mon doigt avait glissé, chef!
A+...peut-être à l'étape suivante.
Roland

[nicrolfi]

Bonjour,
Pour f-leb:
Je viens d'avoir le temps d'un peu m'amuser...
Super, cela marche déjà très bien...
La valeur "intervalle" règle bien la vitesse de défilement.
Cela défile de bas en haut avec les lettres collées les unes aux autres...
Je vais essayer de faire défiler de droite à gauche (je trouve que c'est plus agréable et de plus il y aura 3 colonnes "vides" entre les lettres car elles ne prennent que 5 colonnes/8.
Grand grand merci.
NB: j'ai pas mal compris ton code qui est court et efficace!
A bientôt
Roland

[nicrolfi]

Bonjour à tous...
Après quelques jours (pas à temps plein quand même!) d'essais, je suis toujours au point mort.
Qui peut me donner un coup de pouce?
Merci d'avance pour le temps que vous me consacrez.
Roland

[f-leb]

Bonjour,

Au message précédent cela marchait déjà très bien pourtant...

Quel est le nouveau problème, et où en est le code (nouvelle version à poster) ?

[nicrolfi]

Bonjour,
Merci pour votre réponse.
La dernière version fonctionne mais le défilement se fait de bas en haut et les lettres sont collées les une aux autres (pas facile à lire!).
J'ai essayé de faire défiler de droite à gauche, ce qui est plus lisible et de plus il y aurait 3 colonnes "vides" entre chaque lettre puisque les lettres sont "dessinées" en 5 leds de large.
J'ai réfléchi à modifier le code (surtout en jouant sur les lignes et colonnes) et essayé mais sans succès...
C'est sans doute dans le update display qu'il faut modifier, mais où? Ou alors à la dernière ligne du setpattern?
Je suis revenu au dernier code envoyé...
Merci d'avance pour vos lumières.
Roland

[f-leb]

Merci de reposter quand même le code complet, je n'ai que des bouts de code répartis dans plusieurs messages sur deux pages.

[nicrolfi]

Bonjour,
merci pour le retour.
Désolé voici le code qui fonctionne comme décrit ci-dessus:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
// Dot_matrix_ICONS.ino
 
#define Heart {{0, 1, 0, 0, 0, 1, 0, 0}, \
    {1, 0, 1, 0, 1, 0, 1, 0}, \
    {1, 0, 0, 1, 0, 0, 1, 0}, \
    {0, 1, 0, 0, 0, 1, 0, 0}, \
    {0, 0, 1, 0, 1, 0, 0, 0}, \
    {0, 0, 0, 1, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0} \
  }
#define Arrow {{0, 0, 0, 0, 1, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 1, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 1, 0}, \
    {1, 1, 1, 1, 1, 1, 1, 1}, \
    {1, 1, 1, 1, 1, 1, 1, 1}, \
    {0, 0, 0, 0, 0, 0, 1, 0}, \
    {0, 0, 0, 0, 0, 1, 0, 0}, \
    {0, 0, 0, 0, 1, 0, 0, 0} \
  }
#define Anchor {{0, 0, 0, 1, 1, 0, 0, 0}, \
    {0, 0, 1, 1, 1, 1, 0, 0}, \
    {0, 0, 0, 1, 1, 0, 0, 0}, \
    {0, 0, 0, 1, 1, 0, 0, 0}, \
    {1, 0, 0, 1, 1, 0, 0, 1}, \
    {1, 0, 0, 1, 1, 0, 0, 1}, \
    {0, 1, 0, 1, 1, 0, 1, 0}, \
    {0, 0, 1, 1, 1, 1, 0, 0} \
  }
#define Space {{0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0} \
  }
#define E {{1, 1, 1, 1, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 1, 1, 0, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 0, 0, 0, 0}, \
    {1, 1, 1, 1, 1, 0, 0, 0}, \
  }
#define J {{1, 1, 1, 1, 1, 0, 0, 0}, \
    {0, 0, 0, 0, 1, 0, 0, 0}, \
    {0, 0, 0, 0, 1, 0, 0, 0}, \
    {0, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 1, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {0, 1, 1, 1, 0, 0, 0, 0}, \
  }
#define T {{1, 1, 1, 1, 1, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
  }
#define Apos {{0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0} \
  }
#define A {{0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 1, 0, 1, 0, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 1, 1, 1, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0} \
  }
#define I {{1, 1, 1, 1, 1, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {0, 0, 1, 0, 0, 0, 0, 0}, \
    {1, 1, 1, 1, 1, 0, 0, 0} \
  }
#define M {{1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 1, 0, 1, 1, 0, 0, 0}, \
    {1, 0, 1, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0}, \
    {1, 0, 0, 0, 1, 0, 0, 0} \
  }
#define Bafaire {{0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0}, \
    {0, 0, 0, 0, 0, 0, 0, 0} \
  }
//
int k = 0;
const unsigned long interval = 100;
byte column = 0;
byte LEDs[8][8];
int col[8] = {6, 11, 10, 3, 17, 4, 8, 9};
int row[8] = {2, 7, 19, 5, 13, 18, 12, 16};
byte patterns[9][8][8] = { J, E, Space, T, Apos, A, I, M, E};
void setup()
{ for (int i = 2; i <= 19; i++) pinMode(i, OUTPUT);
  for (int i = 1; i <= 8; i++) digitalWrite(col[i - 1], HIGH);
  for (int i = 1; i <= 8; i++) digitalWrite(row[i - 1], HIGH);
}
//
void loop()
{
 
  for (int decalage = 0; decalage < 8 * (9 - 1); decalage++)
  { clearArray();
    setPattern(decalage);
    unsigned long start = millis();
    while ((millis() - start) <= interval)
    {
      updateDisplay();
      delay(1);
    }
  }
}
 
//
void clearArray()
{ for (int i = 0; i < 8; i++)
  { for (int j = 0; j < 8; j++)LEDs[i][j] = 0;
 
  }
}
 
//
void setPattern(int decalage)
 
{ for (int i = 0; i < 8; i++)
  { for (int j = 0; j < 8; j++)
    { int colIndex = (j + decalage) % 8;
      int patternIndex = (decalage + j) / 8;
      LEDs[i][j] = patterns[patternIndex][colIndex][i];
      //LEDs[i][j] = patterns[colIndex][patternIndex][i];
    }
  }
}
//
void updateDisplay()
{
  for (int i = 0; i < 8; i++)
  { digitalWrite(col[i], HIGH);
    digitalWrite(row[i], LOW);
  }
  //
  column++;
 
  if (column == 8) column = 0;
 
 
  for (int r = 0; r < 8; r++)
  {
    if (LEDs[column][r] == 1) digitalWrite(row[r], HIGH);
    //if (LEDs[rangee][r] == 1) digitalWrite(row[r], HIGH);
 
    else digitalWrite(row[r], LOW);
  }
 
  digitalWrite(col[column], LOW);
}

Merci d'avance pour vos suggestions...
roland

[f-leb]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

LEDs[i][j] = patterns[patternIndex][colIndex][i];

Je m'embrouille...
Essaie avec : LEDs[i][j] = patterns[patternIndex][j][colindex];.

[nicrolfi]

Merci pour la réponse,
Cela ne marche pas...On obtient des lignes de leds se déplaçant vers le haut...
Pas facile de ne pas s'embrouiller!
A bientôt
Roland

[nicrolfi]

Ouf, ça y est...
Votre proposition m'a donné une idée...
Voilà ce qui fonctionne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void setPattern(int decalage)
 
{ for (int i = 0; i < 8; i++)
  { for (int j = 0; j < 8; j++)
    { int colIndex = (i + decalage) % 8;
      int patternIndex = (decalage + i) / 8;
      LEDs[i][j] = patterns[patternIndex][j][colIndex];
 
      }
    }
  }

En plus de votre proposition, il faut aussi changer j en i sur les 2 lignes précédentes!
Encore merci.
PS: je vais sans doute maintenant tester le module 8x8 mais avec un driver...
A bientôt
Roland

[f-leb]

Bien joué ! La version finale du programme complet accompagnée d'une petite vidéo de démonstration youtube comme tu l'as fait précédemment serait magnifique comme contribution pour de futurs lecteurs de passage ici