Faire défiler des images sur une matrice de leds

**nicrolfi** · 24/01/2025, 18h23

Bonjour,
Je poursuis mes petits essais avec les leds.
J'avais un module 8x8 monochrome 1088BS dans mes "réserves"...Il faisait partie d'un kit pour expérimenter les applications d'un livre...MAIS le module fourni n'était pas le même que celui décrit dans le bouquin...Donc quelques chipotages pour arriver à comprendre.
NB j'ai aussi un module 8x8 avec driver jamais utilisé! Ce sera pour après!
C'était aussi une histoire d'anodes et de cathodes. Problème résolu.
Voici le sketch qui correspond (après quelques modifs de ma part à celui fourni avec le bouquin).
Il fonctionne et permet d'afficher l'une des icones (ou lettres mises sous forme de matrice) .

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
 
// 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 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 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}, \
}
//
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[1][8][8] = { E }; //{ Heart, Arrow, Anchor };
//
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 k=1; k=2;k++)
{if (k=1); 
{
clearArray();  
setPattern(0);
updateDisplay();
}
}
}
//
void clearArray()
{ for (int i = 0; i < 8; i++)
{ for (int j = 0; j < 8; j++) LEDs[i][j] = 0;
}
}
//
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];
}
}
//
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);
else digitalWrite(row[r], LOW);
}
digitalWrite(col[column], LOW);        
}

Je ne suis pas certain que mon code s'est bien installé!!!! Je ne sais plus comment le mettre bien avec des balises code. Désolé.
Dans les premières accolades de la ligne:
byte patterns[1][8][8] = { E }; //{ Heart, Arrow, Anchor };,
je peux choisir l'icone que je veux voir apparaître sur le module. Et il y reste!
Ce que je souhaite faire c'est faire défiler plusieurs icones (dans un premier temps: une icone apparait 1 seconde, puis une autre apparait et ainsi de suite (en indiquant d'avance quelles icones doivent se succéder).
J'ai essayé 36 solutions mais rien ne marche.
Qui peut me donner une piste de solution?
Merci d'avance
Roland

**f-leb** · 24/01/2025, 18h50

Salut,

Code :

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

byte patterns[1][8][8] = { E }; //{ Heart, Arrow, Anchor };

La réponse est dans le commentaire, non ?

Code :

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

byte patterns[3][8][8] = { Heart, Arrow, Anchor };

Et ensuite, quelque chose dans ce genre...

Code :

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

1
2
3
4
5
6
clearArray();
for (int k=0; k<3; k++) {
  setPattern(k);
  updateDisplay();
  delay(1000); // Ne pas oublier le delay(), merci umfred ;)
}

**edgarjacobs** · 24/01/2025, 19h26

Hello,

Une piste, mais ce n'est qu'une idée basique (codé en C)

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
#include <stdio.h>
 
int alphabet[][8][8]={
    // 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} 
    },
    // 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} 
    },
    // 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}
    },
    // 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}
    },
    // 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}
    },
    // 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}
    }
};
 
enum my_alphabet {HEART, ARROW, ANCHOR, SPACE, J, E};
 
void DisplayPattern(int pattern [8][8]) {
    for(int i=0; i<8; ++i) {
        for(int j=0; j<8; ++j)
            printf("%d ", pattern[i][j]);    // Serial.print
        puts("");                                  // Serial.printnl
    }
}
 
 
int main(void) {
    int chars_to_be_displayed[]={J, ANCHOR, ARROW, SPACE, E};
 
    for(unsigned int i=0; i<sizeof(chars_to_be_displayed)/sizeof(chars_to_be_displayed[0]); ++i) {
        int offset=chars_to_be_displayed[i];
        DisplayPattern(alphabet[offset]);
        puts("");                                  // Serial.printnl
    }
}

Edit: code (présentation)

**nicrolfi** · 24/01/2025, 19h26

Bonsoir,
Voici le code mis à jour comme proposé:

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
// 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 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 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}, \
}
//
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[1][8][8] = { E }; //{ Heart, Arrow, Anchor };
byte patterns[3][8][8] = { Heart, Arrow,Arrow};
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 k=1; k=2;k++)
{if (k=1); 
{
clearArray();
for (k=0; k<3;k++); 
setPattern(k);
updateDisplay();
}
}
}
//
void clearArray()
{ for (int i = 0; i < 8; i++)
{ for (int j = 0; j < 8; j++) LEDs[i][j] = 0;
}
}
//
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];
}
}
//
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);
else digitalWrite(row[r], LOW);
}
digitalWrite(col[column], LOW);        
}

Il n'y a pas d'erreur de compilation mais rien n'apparait sur le module 8x8!!!
Une idée?
Merci pour votre aide.
Roland

**nicrolfi** · 24/01/2025, 19h33

Bonsoir,

Une piste, mais ce n'est qu'une idée basique

Merci pour votre réponse, je vais étudier votre programme.
Il y a pas mal de choses dont je dois chercher la signification ou l'usage.
Je vous reviens.
Roland

**nicrolfi** · 24/01/2025, 19h44

Re bonsoir,

il doit manquer un delay après le updateDisplay, histoire d'avoir le temps de voir l'affichage

Mainteant une ou l'autre led s'allume (parfois faiblement) d'une manière disparate...
J'ai fait varier le delay cela change le temps d'affichage de ces leds disparate...
Je pense qu'effectivement, il y a là une idée à creuser mais il n'y a sans doute pas que ce problème...
Merci pour votre réponse.
Roland

**f-leb** · 24/01/2025, 19h45

Envoyé par nicrolfi

Code :

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

1
2
3
4
5
6
7
8
9
10
11
...
for (int k=1; k=2;k++)
{if (k=1); 
{
clearArray();
for (k=0; k<3;k++); 
setPattern(k);
updateDisplay();
}
}
...

Ce n'est pas vraiment ce que j'ai écrit...

**f-leb** · 24/01/2025, 19h53

Mmhhh... y aurait-il aussi un multiplexage à gérer ? C'est sans doute plus compliqué que prévu, je reviendrais plus tard...

Edit : évidemment qu'il y a le multiplexage à gérer, le code ne marchera pas tel quel....

**f-leb** · 24/01/2025, 20h16

à tester...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// ...
const unsigned long interval = 1000;
//...
 
for (int k=0; k<3; k++) {
  clearArray();
  setPattern(k);
 
  unsigned long start = millis();
  while ((millis() - start) <= interval) {
    updateDisplay();
    delay(1);
  }
}

**nicrolfi** · 24/01/2025, 20h50

Le point:
J'ai corrigé...
Cela marche en partie:
Le coeur s'écrit sur le module mais ensuite, plus rien: c'est comme si il n'y avait qu'un motif à afficher.
Le delay ne fait que ralentir l'écriture du coeur...donc on ne voit qu'une colonne à la fois. en supprimant ce delay, le coeur s'affiche normalement sans clignotement.
Le delay n'est pas mis au bon endroit?
Ah oui, j'ai du indiquer int k; en tête du programme, sinon message à la compilation: k n'a pas été défini dans ce scope.
Encore merci pour vos cogitations et suggestions. Ca avance!!!
A+
Roland

**umfred** · 24/01/2025, 19h33

il doit manquer un delay après le updateDisplay, histoire d'avoir le temps de voir l'affichage

**Jay M** · 27/01/2025, 16h54

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** · 27/01/2025, 17h02

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

**f-leb** · 27/01/2025, 21h19

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** · 27/01/2025, 23h08

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** · 27/01/2025, 23h17

Hello,

Ligne 28, i++ ??

C'est le débordement assuré.

Faire défiler des images sur une matrice de leds

Arduino

Vue hybride

Discussions similaires

Partager

Partager