J'utilise un compteur de boucles, déclaré dans un en-tête:
int loop_counter = 0;
J'utilise ce compteur pour déclencher un événement de temps en temps. J'avais l'habitude d'utiliser un modulo pour ce même type de comportement, mais je l'ai simplifié pour qu'il soit plus facile de travailler avec (il en résulte toujours le même comportement)
void loop() {
if(loop_counter > 100) loop_counter = 0;
else loop_counter++;
//Serial.println("hey");
if(loop_counter == 0) {
//do_something_important();
}
}
Tout va bien, jusqu'à ce que j'essaie de communiquer avec Serial
en décommentant le //Serial.println("hey");
( "hey"
dans cet exemple parce que, pour moi, ce comportement est absurde).
Cela se traduit par loop_counter
ne jamais déclencher la do_something_important();
section de code. J'ai essayé de déclarer loop_counter
que volatile
cela ne changeait rien. J'ai essayé Serial.print
ing loop_counter
, et j'obtenais aussi un comportement étrange (cela gèlerait la boucle). Serial.println("hey");
fonctionne en ce sens que dans le moniteur série, j'obtiens beaucoup de "hey", (c'est-à-dire rapidement beaucoup plus de 100 "heys", le nombre d'itérations auxquelles l'autre section de code devrait se déclencher)
Qu'est-ce qui pourrait éventuellement causer l'utilisation de Serial
, avec des données qui ne sont pas (pour autant que je sache) liées à l' loop_counter
empêcher complètement de fonctionner correctement?
EDIT : Voici la partie du fichier principal qui a fini par poser le problème (enfin, y contribuer le plus (utiliser trop de mémoire)):
void display_state() {
int i,j,index=0;
short alive[256][2];
for(i=0;i<num_rows;i++) {
for(j=0;j<num_cols;j++) {
if(led_matrix[i][j]==1) {
alive[index][0]=i;
alive[index][1]=j;
index++;
}
}
}
alive[index][0]=NULL; //Null-terminate.
alive[index][1]=NULL;
//383 is a great number
for(int idx=0;idx < index; idx++) {
display(alive[idx][0],alive[idx][1]);
delayMicroseconds(283);
}
}
Voici "letters.h":
#ifndef _MY_LETTERS_H #define _MY_LETTERS_H
#define nrows 4 #define ncols 4 #define num_rows 16 #define num_cols 16 #define MAX_WORD_LENGTH 16 #define NUMBER_OF_CHARACTERS 26 #include <stdlib.h>
int loop_counter = 0;loop_counter = 0 ; short led_matrix [num_rows] [num_cols];short led_matrix [ num_rows ] [ num_cols ];
const short letter_a [nrows] [ncols] = {{0,1,1,0}, short letter_a [ nrows ] [ ncols ] = {{ 0 , 1 , 1 , 0 }, {1,0,0,1},{ 1 , 0 , 0 , 1 }, {1,1,1,1},{ 1 , 1 , 1 , 1 }, {1,0,0,1}};{ 1 , 0 , 0 , 1 }}; const short letter_b [nrows] [ncols] = {{1,0,0,0}, {1,1,1,0}, {1,0,1,0}, {1,1,1,0} };const short letter_b [ nrows ] [ ncols ] = {{ 1 , 0 , 0 , 0 }, { 1 , 1 , 1 , 0 }, { 1 , 0 , 1 , 0 }, { 1 , 1 , 1 , 0 } }; const short letter_c [nrows] [ncols] = {{0,1,1,1}, {1,0,0,0}, {1,0,0,0}, {0,1,1,1} };const short letter_c [ nrows ] [ ncols ] = {{ 0 , 1 , 1 , 1 }, { 1 , 0 , 0 , 0 }, { 1 , 0 , 0 , 0 }, { 0 , 1 , 1 , 1 } }; const short letter_t [nrows] [ncols] = {{1,1,1,1}, {0,1,0,0}, {0,1,0,0}, {0,1,0,0} };const short letter_t [ nrows ] [ ncols ] = {{ 1 , 1 , 1 , 1 }, { 0 , 1 , 0 , 0 }, { 0 , 1 , 0 , 0 }, { 0 , 1 , 0 , 0 } };
typedef struct letter_node { struct letter_node { const short * data;const short * data ; letter_node * suivant;* suivant ; int x;int x ; int y;int y ; } letter_node;} letter_node ;
letter_node aa = {& letter_a [0] [0], NULL, 1,1};= {& letter_a [ 0 ] [ 0 ], NULL , 1 , 1 }; letter_node bb = {& letter_b [0] [0], NULL, 1,1};= {& letter_b [ 0 ] [ 0 ], NULL , 1 , 1 }; letter_node cc = {& letter_c [0] [0], NULL, 1,1};= {& letter_c [ 0 ] [ 0 ], NULL , 1 , 1 }; letter_node tt = {& letter_t [0] [0], NULL, 1,1};= {& letter_t [ 0 ] [ 0 ], NULL , 1 , 1 };
letter_node letter_map [NUMBER_OF_CHARACTERS];[ NUMBER_OF_CHARACTERS ]; #fin si#fin si
Quelques informations supplémentaires: - J'utilise un Uno (ATMega328)
loop()
fonction. Comment dois-je peindre ma pile si la seule méthode de sortie que j'ai ( Serial.print()
) échoue?