Un petit problème dans mon code

Bonjour,

Je débute en Arduino et j’ai un petit problème avec mon code.

Alors avant d’indiquer le problème le problème une petite introduction.

J’ai fait un tissage avec différents matériaux: fils, bandes plastiques, cordes… et j’y ai intégré des leds. ( au nombre de 20, mais elles sont couplées par deux par broche.)
Et pour ces leds j’ai fait ce code pour faire clignoter mes leds selon une certaine partition.
Dans cette partition, il y a ce que j’ai appelé “temps” qui correspond donc à une combinaison d’état ( 1 ou 0 soit low ou high) pour toutes mes leds et ce temps correspond à 100 ms.
Et du coup ma partition, c’est une suite d’un nombre “i” de différents temps.

Mon problème c’est: tant que je reste en dessous de 101 temps, soit i<100, j’ai aucun soucis
mais dès que i est supérieur à ce nombre, bim, aucun problème je peux téléverser mon code, le téléversement se produit bien mais aucune de mes leds ne s’allument.

Pas de problème non plus au niveau de l’espace: Voici ce qui est indiqué:

Le croquis utilise 9286 octets (28%) de l’espace de stockage de programmes. Le maximum est de 32256 octets.
Les variables globales utilisent 184 octets (8%) de mémoire dynamique, ce qui laisse 1864 octets pour les variables locales. Le maximum est de 2048 octets.

Voici mon code du coup

// definition

int LED_R1 = 4;
int LED_Rm2 = 5;
int LED_R3 = 6;
int LED_R4 = 7;
int LED_B1 = 8;
int LED_B2 = 9;
int LED_Bm3 = 10;
int LED_B4 = 11;
int LED_J1 = 3;
int LED_J2 = 12;


void setup() {
 pinMode(LED_R1, OUTPUT);
 pinMode(LED_Rm2, OUTPUT);
 pinMode(LED_R3, OUTPUT);
 pinMode(LED_R4, OUTPUT); 
 pinMode(LED_B1, OUTPUT);
 pinMode(LED_B2, OUTPUT);
 pinMode(LED_Bm3, OUTPUT);
 pinMode(LED_B4, OUTPUT);
 pinMode(LED_J1, OUTPUT);
 pinMode(LED_J2, OUTPUT);

 digitalWrite(LED_R1, LOW);
 digitalWrite(LED_Rm2, LOW);
 digitalWrite(LED_R3, LOW);
 digitalWrite(LED_R4, LOW);
 digitalWrite(LED_B1, LOW);
 digitalWrite(LED_B2, LOW);
 digitalWrite(LED_Bm3, LOW);
 digitalWrite(LED_B4, LOW);
 digitalWrite(LED_J1, LOW);
 digitalWrite(LED_J2, LOW);

 
Serial.begin(9600);
}

void loop() {

 for (int i = 0; i < 124; i ++)
{

    // fonction readMax qui lit les différentes combinaisons
    readMax(i);
    delay(100);
}
}
 int readMax(int temps){

   int controlPin[] = {LED_R1, LED_Rm2, LED_R3, LED_R4, LED_B1, LED_B2, LED_Bm3, LED_B4, LED_J1, LED_J2};
   int maxtemps[124][10]= {

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

     // texte en morse

       {1,0,0,1,1,0,0,1,1,1}, // temps 11
       {1,0,0,1,1,0,0,1,1,1}, // temps 12  
       {1,0,0,1,1,0,0,1,1,1}, // temps 13
       {1,0,0,1,1,0,0,1,1,1}, // temps 14
       {1,0,0,1,1,0,0,1,1,1}, // temps 15    
       {1,0,0,1,1,0,0,1,1,1}, // temps 16
       {1,0,0,1,1,0,0,1,1,1}, // temps 17
       {1,0,0,1,1,0,0,1,1,1}, // temps 18
       {1,0,0,1,1,0,0,1,1,1}, // temps 19
       {1,0,0,1,1,0,0,1,1,1}, // temps 20

      {0,0,0,0,0,0,0,0,1,1}, // temps 21
      {0,0,0,0,0,0,0,0,1,1}, // temps 22

     
       {1,0,0,1,1,0,0,1,1,1}, // temps 23
       {1,0,0,1,1,0,0,1,1,1}, // temps 24  
       {1,0,0,1,1,0,0,1,1,1}, // temps 25
       

     {0,0,0,0,0,0,0,0,1,1}, // temps 26
     {0,0,0,0,0,0,0,0,1,1}, // temps 27
     {0,0,0,0,0,0,0,0,1,1}, // temps 28
     {0,0,0,0,0,0,0,0,1,1}, // temps 29


       {1,0,0,1,1,0,0,1,1,1}, // temps 30
       {1,0,0,1,1,0,0,1,1,1}, // temps 31  
       {1,0,0,1,1,0,0,1,1,1}, // temps 32
       {1,0,0,1,1,0,0,1,1,1}, // temps 33
       {1,0,0,1,1,0,0,1,1,1}, // temps 34
       {1,0,0,1,1,0,0,1,1,1}, // temps 35
       {1,0,0,1,1,0,0,1,1,1}, // temps 36
       {1,0,0,1,1,0,0,1,1,1}, // temps 37
       {1,0,0,1,1,0,0,1,1,1}, // temps 38
       {1,0,0,1,1,0,0,1,1,1}, // temps 39

      {0,0,0,0,0,0,0,0,1,1}, // temps 40
      {0,0,0,0,0,0,0,0,1,1}, // temps 41

       {1,0,0,1,1,0,0,1,1,1}, // temps 42
       {1,0,0,1,1,0,0,1,1,1}, // temps 43  
       {1,0,0,1,1,0,0,1,1,1}, // temps 44
       {1,0,0,1,1,0,0,1,1,1}, // temps 45
       {1,0,0,1,1,0,0,1,1,1}, // temps 46
       {1,0,0,1,1,0,0,1,1,1}, // temps 47
       {1,0,0,1,1,0,0,1,1,1}, // temps 48
       {1,0,0,1,1,0,0,1,1,1}, // temps 49
       {1,0,0,1,1,0,0,1,1,1}, // temps 50
       {1,0,0,1,1,0,0,1,1,1}, // temps 51

      {0,0,0,0,0,0,0,0,1,1}, // temps 52
      {0,0,0,0,0,0,0,0,1,1}, // temps 53
       
       {1,0,0,1,1,0,0,1,1,1}, // temps 54
       {1,0,0,1,1,0,0,1,1,1}, // temps 55  
       {1,0,0,1,1,0,0,1,1,1}, // temps 56
       {1,0,0,1,1,0,0,1,1,1}, // temps 57
       {1,0,0,1,1,0,0,1,1,1}, // temps 58
       {1,0,0,1,1,0,0,1,1,1}, // temps 59
       {1,0,0,1,1,0,0,1,1,1}, // temps 60
       {1,0,0,1,1,0,0,1,1,1}, // temps 61
       {1,0,0,1,1,0,0,1,1,1}, // temps 62
       {1,0,0,1,1,0,0,1,1,1}, // temps 63

     
     {0,0,0,0,0,0,0,0,1,1}, // temps 64
     {0,0,0,0,0,0,0,0,1,1}, // temps 65
     {0,0,0,0,0,0,0,0,1,1}, // temps 66
     {0,0,0,0,0,0,0,0,1,1}, // temps 67

       {1,0,0,1,1,0,0,1,1,1}, // temps 68
       {1,0,0,1,1,0,0,1,1,1}, // temps 69  
       {1,0,0,1,1,0,0,1,1,1}, // temps 70

      {0,0,0,0,0,0,0,0,1,1}, // temps 71
      {0,0,0,0,0,0,0,0,1,1}, // temps 72

       {1,0,0,1,1,0,0,1,1,1}, // temps 73
       {1,0,0,1,1,0,0,1,1,1}, // temps 74  
       {1,0,0,1,1,0,0,1,1,1}, // temps 75

      {0,0,0,0,0,0,0,0,1,1}, // temps 76
      {0,0,0,0,0,0,0,0,1,1}, // temps 77

       {1,0,0,1,1,0,0,1,1,1}, // temps 78
       {1,0,0,1,1,0,0,1,1,1}, // temps 79  
       {1,0,0,1,1,0,0,1,1,1}, // temps 80
       {1,0,0,1,1,0,0,1,1,1}, // temps 81
       {1,0,0,1,1,0,0,1,1,1}, // temps 82
       {1,0,0,1,1,0,0,1,1,1}, // temps 83
       {1,0,0,1,1,0,0,1,1,1}, // temps 84
       {1,0,0,1,1,0,0,1,1,1}, // temps 85
       {1,0,0,1,1,0,0,1,1,1}, // temps 86
       {1,0,0,1,1,0,0,1,1,1}, // temps 87
       

     {0,0,0,0,0,0,0,0,1,1}, // temps 88
     {0,0,0,0,0,0,0,0,1,1}, // temps 89
     {0,0,0,0,0,0,0,0,1,1}, // temps 90
     {0,0,0,0,0,0,0,0,1,1}, // temps 91

       {1,0,0,1,1,0,0,1,1,1}, // temps 92
       {1,0,0,1,1,0,0,1,1,1}, // temps 93  
       {1,0,0,1,1,0,0,1,1,1}, // temps 94

      {0,0,0,0,0,0,0,0,1,1}, // temps 95
      {0,0,0,0,0,0,0,0,1,1}, // temps 96

       {1,0,0,1,1,0,0,1,1,1}, // temps 97
       {1,0,0,1,1,0,0,1,1,1}, // temps 98  
       {1,0,0,1,1,0,0,1,1,1} // temps 99

      {0,0,0,0,0,0,0,0,1,1}, // temps 100
      {0,0,0,0,0,0,0,0,1,1}, // temps 101

       {1,0,0,1,1,0,0,1,1,1}, // temps 102
       {1,0,0,1,1,0,0,1,1,1}, // temps 103 
       {1,0,0,1,1,0,0,1,1,1}, // temps 104
       

     {0,0,0,0,0,0,0,0,1,1}, // temps 105
     {0,0,0,0,0,0,0,0,1,1}, // temps 106
     {0,0,0,0,0,0,0,0,1,1}, // temps 107
     {0,0,0,0,0,0,0,0,1,1}, // temps 108
      

       {1,0,0,1,1,0,0,1,1,1}, // temps 109
       {1,0,0,1,1,0,0,1,1,1}, // temps 110  
       {1,0,0,1,1,0,0,1,1,1}, // temps 111

      {0,0,0,0,0,0,0,0,1,1}, // temps 112
      {0,0,0,0,0,0,0,0,1,1}, // temps 113

       {1,0,0,1,1,0,0,1,1,1}, // temps 114
       {1,0,0,1,1,0,0,1,1,1}, // temps 115  
       {1,0,0,1,1,0,0,1,1,1}, // temps 116
       {1,0,0,1,1,0,0,1,1,1}, // temps 117
       {1,0,0,1,1,0,0,1,1,1}, // temps 118
       {1,0,0,1,1,0,0,1,1,1}, // temps 119
       {1,0,0,1,1,0,0,1,1,1}, // temps 120
       {1,0,0,1,1,0,0,1,1,1}, // temps 121
       {1,0,0,1,1,0,0,1,1,1}, // temps 122
       {1,0,0,1,1,0,0,1,1,1} // temps 123
     
       
   

     
   };
   
    

   // boucle

   for ( int i = 0; i < 10; i++)
   {

     digitalWrite(controlPin[i], maxtemps[temps][i]);
   }
 
   }

Du coup j’aimerais savoir ce qui ne va pas et si quelqu’un aurait une solution pour palier à ce problème, merci d’avance de vos réponses ???

Bonjour Hangharber

Le programme joint ne compile pas et les tailles programme et données ne correpondent pas.

Cordialement, bidouilleelec

Hangarber:
Mon problème c’est: tant que je reste en dessous de 101 temps, soit i<100, j’ai aucun soucis
mais dès que i est supérieur à ce nombre, bim, aucun problème je peux téléverser mon code, le téléversement se produit bien mais aucune de mes leds ne s’allument.

Pas de problème non plus au niveau de l’espace: Voici ce qui est indiqué:

Le croquis utilise 9286 octets (28%) de l’espace de stockage de programmes. Le maximum est de 32256 octets.
Les variables globales utilisent 184 octets (8%) de mémoire dynamique, ce qui laisse 1864 octets pour les variables locales. Le maximum est de 2048 octets.

Oui mais le rapport de compilation ne prend en compte que les variables globales pas les variables locales.
Or dans readmax() il y a ça

 int readMax(int temps){

   int controlPin[] = {LED_R1, LED_Rm2, LED_R3, LED_R4, LED_B1, LED_B2, LED_Bm3, LED_B4, LED_J1, LED_J2};
   int maxtemps[124][10]= {

maxtemps utilise 124 * 10 * 2 = 2480 octets donc tu dépasse largement la taille mémoire d’un ATmega328

Dans un premier temps, tu pourrais diviser la taille mémoire occupée par 2 en déclarant un tableau d’unsigned char plutôt qu’un tableau d’int.
Ensuite, les éléments de maxtemps contiennent 10 valeurs 0 ou 1 donc tu pourrais très bien stocker ces valeurs dans un unsigned int et du coup ton tableau n’aurait qu’une taille de 124 entiers soit 248 octets.

Bonjour fdufnews

fdufnews: Oui mais le rapport de compilation ne prend en compte que les variables globales pas les variables locales.

Chez moi l'IDE (1.8.5) tient compte des variables locales.

Cordialement, bidouilleelec

Si je compile (après avoir rajouté la virgule) sur un UNO j'ai

Sketch uses 4842 bytes (15%) of program storage space. Maximum is 32256 bytes.
Global variables use 2664 bytes ([color=red]130%[/color]) of dynamic memory, [color=red]leaving -616 bytes for local variables[/color]. Maximum is 2048 bytes.
[color=red]Not enough memory[/color]; see [url=http://www.arduino.cc/en/Guide/Troubleshooting#size]http://www.arduino.cc/en/Guide/Troubleshooting#size[/url] for tips on reducing your footprint.
[color=red]Error compiling for board Arduino/Genuino Uno.[/color]

comme l'animation est statique, vous pourriez la mettre en mémoire programme (et comme suggéré passer en stockage sur des bits si vous voulez vraiment condenser)

PS/ la fonction readMax ne retournant rien, c'est pas beau de mentir au compilateur en lui disant qu'elle retourne un int... :)int readMax(int temps){

bidouilleelec: Bonjour Hangharber

Le programme joint ne compile pas et les tailles programme et données ne correpondent pas.

Cordialement, bidouilleelec

Il manque une virgule au temps 99

{1,0,0,1,1,0,0,1,1,1}, // temps 98 {1,0,0,1,1,0,0,1,1,1} // temps 99

{0,0,0,0,0,0,0,0,1,1}, // temps 100 {0,0,0,0,0,0,0,0,1,1}, // temps 101

Cordialement jpbbricole

Bonsoir Hangarber

Hangarber:
Mon problème c’est: tant que je reste en dessous de 101 temps, soit i<100, j’ai aucun soucis

Le premier problème, c’est le gaspillage de mémoire, pour “allumer et éteindre” un port, le tableau est du type int (16 bits) alors que du boolean suffit (1 ou 0) et utilise 8 bits donc économie
J’ai changé

int maxtemps[124][10]= {
en
boolean maxtemps[124][10]= {

ensuite, la situation de ce tableau n’est pas optimale, je l’ai déplacé “tout en haut” de façon qu’il soit global.

Voici le code corrigé

// definition

int LED_R1 = 4;
int LED_Rm2 = 5;
int LED_R3 = 6;
int LED_R4 = 7;
int LED_B1 = 8;
int LED_B2 = 9;
int LED_Bm3 = 10;
int LED_B4 = 11;
int LED_J1 = 3;
int LED_J2 = 12;

 boolean maxtemps[124][10]= {

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

 // texte en morse

 {1,0,0,1,1,0,0,1,1,1}, // temps 11
 {1,0,0,1,1,0,0,1,1,1}, // temps 12
 {1,0,0,1,1,0,0,1,1,1}, // temps 13
 {1,0,0,1,1,0,0,1,1,1}, // temps 14
 {1,0,0,1,1,0,0,1,1,1}, // temps 15
 {1,0,0,1,1,0,0,1,1,1}, // temps 16
 {1,0,0,1,1,0,0,1,1,1}, // temps 17
 {1,0,0,1,1,0,0,1,1,1}, // temps 18
 {1,0,0,1,1,0,0,1,1,1}, // temps 19
 {1,0,0,1,1,0,0,1,1,1}, // temps 20

 {0,0,0,0,0,0,0,0,1,1}, // temps 21
 {0,0,0,0,0,0,0,0,1,1}, // temps 22

 
 {1,0,0,1,1,0,0,1,1,1}, // temps 23
 {1,0,0,1,1,0,0,1,1,1}, // temps 24
 {1,0,0,1,1,0,0,1,1,1}, // temps 25
 

 {0,0,0,0,0,0,0,0,1,1}, // temps 26
 {0,0,0,0,0,0,0,0,1,1}, // temps 27
 {0,0,0,0,0,0,0,0,1,1}, // temps 28
 {0,0,0,0,0,0,0,0,1,1}, // temps 29


 {1,0,0,1,1,0,0,1,1,1}, // temps 30
 {1,0,0,1,1,0,0,1,1,1}, // temps 31
 {1,0,0,1,1,0,0,1,1,1}, // temps 32
 {1,0,0,1,1,0,0,1,1,1}, // temps 33
 {1,0,0,1,1,0,0,1,1,1}, // temps 34
 {1,0,0,1,1,0,0,1,1,1}, // temps 35
 {1,0,0,1,1,0,0,1,1,1}, // temps 36
 {1,0,0,1,1,0,0,1,1,1}, // temps 37
 {1,0,0,1,1,0,0,1,1,1}, // temps 38
 {1,0,0,1,1,0,0,1,1,1}, // temps 39

 {0,0,0,0,0,0,0,0,1,1}, // temps 40
 {0,0,0,0,0,0,0,0,1,1}, // temps 41

 {1,0,0,1,1,0,0,1,1,1}, // temps 42
 {1,0,0,1,1,0,0,1,1,1}, // temps 43
 {1,0,0,1,1,0,0,1,1,1}, // temps 44
 {1,0,0,1,1,0,0,1,1,1}, // temps 45
 {1,0,0,1,1,0,0,1,1,1}, // temps 46
 {1,0,0,1,1,0,0,1,1,1}, // temps 47
 {1,0,0,1,1,0,0,1,1,1}, // temps 48
 {1,0,0,1,1,0,0,1,1,1}, // temps 49
 {1,0,0,1,1,0,0,1,1,1}, // temps 50
 {1,0,0,1,1,0,0,1,1,1}, // temps 51

 {0,0,0,0,0,0,0,0,1,1}, // temps 52
 {0,0,0,0,0,0,0,0,1,1}, // temps 53
 
 {1,0,0,1,1,0,0,1,1,1}, // temps 54
 {1,0,0,1,1,0,0,1,1,1}, // temps 55
 {1,0,0,1,1,0,0,1,1,1}, // temps 56
 {1,0,0,1,1,0,0,1,1,1}, // temps 57
 {1,0,0,1,1,0,0,1,1,1}, // temps 58
 {1,0,0,1,1,0,0,1,1,1}, // temps 59
 {1,0,0,1,1,0,0,1,1,1}, // temps 60
 {1,0,0,1,1,0,0,1,1,1}, // temps 61
 {1,0,0,1,1,0,0,1,1,1}, // temps 62
 {1,0,0,1,1,0,0,1,1,1}, // temps 63

 
 {0,0,0,0,0,0,0,0,1,1}, // temps 64
 {0,0,0,0,0,0,0,0,1,1}, // temps 65
 {0,0,0,0,0,0,0,0,1,1}, // temps 66
 {0,0,0,0,0,0,0,0,1,1}, // temps 67

 {1,0,0,1,1,0,0,1,1,1}, // temps 68
 {1,0,0,1,1,0,0,1,1,1}, // temps 69
 {1,0,0,1,1,0,0,1,1,1}, // temps 70

 {0,0,0,0,0,0,0,0,1,1}, // temps 71
 {0,0,0,0,0,0,0,0,1,1}, // temps 72

 {1,0,0,1,1,0,0,1,1,1}, // temps 73
 {1,0,0,1,1,0,0,1,1,1}, // temps 74
 {1,0,0,1,1,0,0,1,1,1}, // temps 75

 {0,0,0,0,0,0,0,0,1,1}, // temps 76
 {0,0,0,0,0,0,0,0,1,1}, // temps 77

 {1,0,0,1,1,0,0,1,1,1}, // temps 78
 {1,0,0,1,1,0,0,1,1,1}, // temps 79
 {1,0,0,1,1,0,0,1,1,1}, // temps 80
 {1,0,0,1,1,0,0,1,1,1}, // temps 81
 {1,0,0,1,1,0,0,1,1,1}, // temps 82
 {1,0,0,1,1,0,0,1,1,1}, // temps 83
 {1,0,0,1,1,0,0,1,1,1}, // temps 84
 {1,0,0,1,1,0,0,1,1,1}, // temps 85
 {1,0,0,1,1,0,0,1,1,1}, // temps 86
 {1,0,0,1,1,0,0,1,1,1}, // temps 87
 

 {0,0,0,0,0,0,0,0,1,1}, // temps 88
 {0,0,0,0,0,0,0,0,1,1}, // temps 89
 {0,0,0,0,0,0,0,0,1,1}, // temps 90
 {0,0,0,0,0,0,0,0,1,1}, // temps 91

 {1,0,0,1,1,0,0,1,1,1}, // temps 92
 {1,0,0,1,1,0,0,1,1,1}, // temps 93
 {1,0,0,1,1,0,0,1,1,1}, // temps 94

 {0,0,0,0,0,0,0,0,1,1}, // temps 95
 {0,0,0,0,0,0,0,0,1,1}, // temps 96

 {1,0,0,1,1,0,0,1,1,1}, // temps 97
 {1,0,0,1,1,0,0,1,1,1}, // temps 98
 {1,0,0,1,1,0,0,1,1,1}, // temps 99

 {0,0,0,0,0,0,0,0,1,1}, // temps 100
 {0,0,0,0,0,0,0,0,1,1}, // temps 101

 {1,0,0,1,1,0,0,1,1,1}, // temps 102
 {1,0,0,1,1,0,0,1,1,1}, // temps 103
 {1,0,0,1,1,0,0,1,1,1}, // temps 104
 

 {0,0,0,0,0,0,0,0,1,1}, // temps 105
 {0,0,0,0,0,0,0,0,1,1}, // temps 106
 {0,0,0,0,0,0,0,0,1,1}, // temps 107
 {0,0,0,0,0,0,0,0,1,1}, // temps 108
 

 {1,0,0,1,1,0,0,1,1,1}, // temps 109
 {1,0,0,1,1,0,0,1,1,1}, // temps 110
 {1,0,0,1,1,0,0,1,1,1}, // temps 111

 {0,0,0,0,0,0,0,0,1,1}, // temps 112
 {0,0,0,0,0,0,0,0,1,1}, // temps 113

 {1,0,0,1,1,0,0,1,1,1}, // temps 114
 {1,0,0,1,1,0,0,1,1,1}, // temps 115
 {1,0,0,1,1,0,0,1,1,1}, // temps 116
 {1,0,0,1,1,0,0,1,1,1}, // temps 117
 {1,0,0,1,1,0,0,1,1,1}, // temps 118
 {1,0,0,1,1,0,0,1,1,1}, // temps 119
 {1,0,0,1,1,0,0,1,1,1}, // temps 120
 {1,0,0,1,1,0,0,1,1,1}, // temps 121
 {1,0,0,1,1,0,0,1,1,1}, // temps 122
 {1,0,0,1,1,0,0,1,1,1} // temps 123
 
 
 

 
 };


void setup() {
 pinMode(LED_R1, OUTPUT);
 pinMode(LED_Rm2, OUTPUT);
 pinMode(LED_R3, OUTPUT);
 pinMode(LED_R4, OUTPUT);
 pinMode(LED_B1, OUTPUT);
 pinMode(LED_B2, OUTPUT);
 pinMode(LED_Bm3, OUTPUT);
 pinMode(LED_B4, OUTPUT);
 pinMode(LED_J1, OUTPUT);
 pinMode(LED_J2, OUTPUT);

 digitalWrite(LED_R1, LOW);
 digitalWrite(LED_Rm2, LOW);
 digitalWrite(LED_R3, LOW);
 digitalWrite(LED_R4, LOW);
 digitalWrite(LED_B1, LOW);
 digitalWrite(LED_B2, LOW);
 digitalWrite(LED_Bm3, LOW);
 digitalWrite(LED_B4, LOW);
 digitalWrite(LED_J1, LOW);
 digitalWrite(LED_J2, LOW);

 
 Serial.begin(9600);
}

void loop() {

 for (int i = 0; i < 124; i ++)
 {

 // fonction readMax qui lit les différentes combinaisons
 readMax(i);
 delay(100);
 }
}
int readMax(int temps){

 int controlPin[] = {LED_R1, LED_Rm2, LED_R3, LED_R4, LED_B1, LED_B2, LED_Bm3, LED_B4, LED_J1, LED_J2};
 
 

 // boucle
 Serial.print(String(temps) + ":");

 for ( int i = 0; i < 10; i++)
 {

 digitalWrite(controlPin[i], maxtemps[temps][i]);
 Serial.print(String(maxtemps[temps][i]) + "-" + String(maxtemps[temps][i]) +  + ",");
 }
 Serial.println("");
}

Bonne bricole
Cordialement
jpbbricole

jpbbricole: Il manque une virgule au temps 99

{1,0,0,1,1,0,0,1,1,1}, // temps 98 {1,0,0,1,1,0,0,1,1,1} // temps 99

{0,0,0,0,0,0,0,0,1,1}, // temps 100 {0,0,0,0,0,0,0,0,1,1}, // temps 101

Cordialement jpbbricole

et à la 123 également

J4l13n: et à la 123 également

Ça ne génére pas d'erreur à la compilation.

Cordialement jpbbricole

Il n’en faut pas puisque c’est la dernière entrée du tableau

Quelques réflexions sur l’optimisation de code:

à noter que booléen ou unsigned char n’est pas le type le plus adapté pour garantir un stockage sur 8 bits sur toutes les plateformes (ou pour le booléen une bonne cohérence de type) suivant la norme et donc utiliser uint8_t ou int8_t serait plus approprié.

Dans ce cas le tableau devient

uint8_t maxtemps[124][10]= {

ce qui fait 1240 octets de mémoire vive (SRAM). ça reste quand même conséquent et si vous voulez stocker deux animations vous aurez un soucis.

L’idée d’optimiser un cran de plus en stockant sur un uint16_t comme proposé par @fdudnews est aussi une bonne idée. On remarque que l’on a que des 1 et des 0 dans le tableau, donc allouer des octets entiers pour ce qui tient sur 1 bit semble être une gabegie de mémoire…

Comment faire cela? il faut convertir les 10 valeurs de pins consécutives en un stockage mémoire binaire.

Par exemple au temps 0 on a cette table {1,0,0,0,0,0,0,0,1,1} - en binaire sur 16 bits on écrirait 0000 0010 0000 0011 ce qui se représente en hexadécimal par 0x0203.

En prenant votre tableau et un petit coup d’excel pour extraire les bits et recalculer les valeurs, on obtient la table

uint16_t maxtemps[] = { // les 10 bits de poids faibles représentent soit HIGH ou LOW
  0x0203 , // temps 0
  0x0383 , // temps 1
  0x03C3 , // temps 2
  0x01E3 , // temps 3
 ...
  0x0267 , // temps 114
  0x0267 , // temps 115
  0x0267 , // temps 116
  0x0267 , // temps 117
  0x0267 , // temps 118
  0x0267 , // temps 119
  0x0267 , // temps 120
  0x0267 , // temps 121
  0x0267 , // temps 122
  0x0267   // temps 123
};

et pour rendre le code un peu plus indépendant d’une taille fixe, on laisse le compilateur calculer la taille et on peut définir une constante qui représente cette valeur dans le code

const size_t nbMaxTemps = sizeof(maxtemps) / sizeof(maxtemps[0]);

On a maintenant donc 124 entiers sur 2 octets soit 248 octets utilisés au lieu des 1240 précédemment, c’est un gain de 80% de la place!

bien sûr se pose la question d’accéder maintenant à ces bits pour jouer avec les LEDs. Pour extraire des bits l’environnement Arduino met à disposition un ensemble de fonctions dont bitRead(). Les bits sont numérotés de 0 à 15 dans notre uint16_t, en partant du bit de droite (dit de poids faible) qui est N° 0 et celui de poids fort qui est 15.

donc si je fais un bitRead(maxtemps[10], 3) je prends le 4ème bit (0,1,2,3 = 4ème bit) de poids faible dans la 10ème entrée du tableau.

Une fois que l’on a compris cela le

digitalWrite(controlPin[i], maxtemps[temps][i]);

qui va mettre la pin de contrôle i à la ième valeur définie dans le tableau - et se souvenant qu’on lit les N° depuis le poids faible deviendra et que l’on en 10 (i varie de 0 à 9)

digitalWrite(controlPin[i], bitRead(maxtemps[temps], 9 - i));

Ce code n’est pas super propre d’un poids de vue sémantique et si on veut pousser un cran plus loin et seulement envoyer LOW et HIGH à nos pins, il faut tester la valeur retournée par bitread() et si c’est 1 envoyé HIGH, si c’est 0 envoyé LOW. On peut faire cela simplement avec l’opérateur ternaire ?: en C++ et écrire

digitalWrite(controlPin[i], (bitRead(maxtemps[temps], 9 - i) == 0 ? LOW : HIGH));

Que peut on faire de plus?

on peut noter qu’on perd 6 bits par ligne - soit vous vous dites que ça permettra d’avoir plus de LEDs dans le futur et conserver cet espace, soit on peut les utiliser pour coder autre chose. Par exemple on voit à la fin de votre tableau

{1,0,0,1,1,0,0,1,1,1}, // temps 114
 {1,0,0,1,1,0,0,1,1,1}, // temps 115
 {1,0,0,1,1,0,0,1,1,1}, // temps 116
 {1,0,0,1,1,0,0,1,1,1}, // temps 117
 {1,0,0,1,1,0,0,1,1,1}, // temps 118
 {1,0,0,1,1,0,0,1,1,1}, // temps 119
 {1,0,0,1,1,0,0,1,1,1}, // temps 120
 {1,0,0,1,1,0,0,1,1,1}, // temps 121
 {1,0,0,1,1,0,0,1,1,1}, // temps 122
 {1,0,0,1,1,0,0,1,1,1} // temps 123

que toutes les valeurs entre le temps 115 et 123 sont identiques. J’imagine que vous faites cela pour définir la durée d’affichage. On pourrait donc utiliser les bits inutilisés pour coder le nombre de répétitions. la représentations binaires serait dddd ddvv vvvv vvvv où dddd dd serait la durée en nombre de répétitions par exemple, codée sur 6 bits (0 à 63) et vv vvvv vvvv comme ci dessus serait la valeur des 10 LEDs.

→ ça permettrait de passer de x lignes qui se répètent à une seule et de mieux gérer les tempos.

Représenter cela commence cependant à être fatiguant car il faut calculer chaque ligne de manière individuelle et la durée va venir se mélanger avec les bit de LEDs… ça simplifie pas le debug. Mais le C (ou C++) peut venir vous aider pour cela avec les structures de champs de bits (bitfield en anglais)!

Regardons ce petit code:

struct elementAffichage_t {
  uint16_t duree: 6;
  uint16_t leds: 10;
} unElement = {8, 0x0267};

void setup() {
  Serial.begin(115200);
  Serial.print("Taille de la structure = ");
  Serial.println(sizeof(unElement));

  Serial.print("unElement contient ");
  Serial.print(unElement.duree);
  Serial.print(" repetitions et affichera les LEDS ");
  Serial.println(unElement.leds, BIN);
}

void loop() {}

si on le fait tourner on verra dans la console:

[color=purple]Taille de la structure = 2
unElement contient [b][color=green]8[/color][/b] repetitions et affichera les LEDS [b][color=green]1001100111[/color][/b][/color]

On retrouve donc bien le codage des 8 répétitions et votre tableau {1,0,0,1,1,0,0,1,1,1} et la structure n’occupera bien que 2 octets en mémoire.

En combinant cela on pourra donc déclarer notre tableau comme

const elementAffichage_t maxtemps[] = {
  {1, 0x0203}, // temps 0
  {1, 0x0383}, // temps 1
...
  {1, 0x0003}, // temps 9
  {1, 0x0000}, // temps 10
  // texte en morse
  {10, 0x0267}, // temps 11 à 20
  {2, 0x0003}, // temps 21 à 22
  // etc ....
};

=> cela va économiser de nombreuses entrées du tableau.

Cette notion de structure de champs de bits est utile pour ne pas avoir à sortir excel et calculer exactement les 10 bits.

struct elementAffichage_t {
  uint16_t duree: 6;
  uint8_t ledsH: 2; // en utilisant la notation arduino on est limité à 8 bits
  uint8_t ledsL: 8; // donc on sépare en 2 morceaux. idéalement utiliser 1 seul uint16_t leds:10;
};

elementAffichage_t maxtemps[] = {
  {12, B11, B10011001}, // si on avait pris la notation uint16_t leds:10 alors {12, 0b1110011001},
  {3, B01, B01010101}, 
  {1, B10, B11110000},
};

const size_t nbMaxTemps = sizeof(maxtemps) / sizeof(maxtemps[0]);

void printByte(uint8_t b, uint8_t startBit)
{
  for (int i = startBit; i >= 0; --i) Serial.print(bitRead(b, i));
}

void setup() {
  Serial.begin(115200);
  Serial.print("Taille de la structure = ");
  Serial.println(sizeof(elementAffichage_t));

  for (size_t i = 0; i < nbMaxTemps; i++) {
    Serial.print("etape="); Serial.print(i);
    Serial.print(" Nb repetition= "); Serial.print(maxtemps[i].duree);
    Serial.print("\tLEDS ");
    printByte(maxtemps[i].ledsH, 1);
    printByte(maxtemps[i].ledsL, 7);
    Serial.println();
  }
}

void loop() {}

si on le fait tourner on verra dans la console:

[color=purple]Taille de la structure = 2
etape=0 Nb repetition= 12 LEDS 1110011001
etape=1 Nb repetition= 3 LEDS 0101010101
etape=2 Nb repetition= 1 LEDS 1011110000[/color]

On pourrait "pousser le vice" encore plus loin.. vu qu'au final une grande partie de ce que vous affichez ce sont les mêmes valeurs (j'imagine trait ou point du morse) qui se répètent, pourquoi coder dans le tableau la configuration exacte des 10 LEDs alors qu'on pourrait simplement se souvenir de si c'est un trait ou un point..

Comme vous n'avez pas que des traits ou des points, il faut cependant garder un peu de flexibilité et donc définir un format de trame qui dit que le tableau ne contient que des octets. Si le poids fort de l'octet est à 1 (bit 7) alors c'est un code morse à executer et vous mettez 6 bits pour la durée et 1 bit pour point ou trait - le format serait 1ddd dddc et si vous voulez affichez un configuration spécifique alors le bit de poids fort serait à 0 et on sait alors qu'il faut prendre 2 octets dans le tableau pour définir l'affichage 0ddd ddvv vvvv vvvv avec une durée sur 5 bits...

bref - le champs des possibles dépend de l'imagination du programmeur, les structure à champs de bit peuvent aider à coder cela simplement.

Une fois tout cela défini bien sûr on peut passer à l'étape suivante, qui est de mettre cela en mémoire programme si le tableau n'est pas amené a changer. pour cela on utilisera la directive PROGMEM par exemple

const PROGMEM  uint16_t maxtemps[] = { // les 10 bits de poids faibles représentent soit HIGH ou LOW
  0x0203 , // temps 0
  0x0383 , // temps 1
...

Bonne optimisation!

Bonjour Hangarber

Une autre méthode, comme c’est des LED avec On/Off, c’est d’utiliser uniquement un bit par LED en utilisant la notation binaire:

0b1000000011, //temps 0 // Utilisation de la notation en bits (0b) pour faciliter la visibilité

Au final, en comparant ta méthode et la mienne ça donne ceci:

Consommation de bytes:
Méthode
int maxtemps[124][10]= {
{1,0,0,0,0,0,0,0,1,1}, //temps 0
= (124 * 10)*2 = 2480
Program size: 4 828 bytes (used 15% of a 32 256 byte maximum) (0,53 secs)
Minimum Memory Usage: 2664 bytes (130% of a 2048 byte maximum)

Méthode
word maxtemps= { // Tableau à qu’une seule dimension parceque usage des bits du word
(B10*256) + B00000011, //temps 0
= 124 *2 = 248
Compiling ‘ARDFR_Hangarber_ProblCodeB’ for ‘Arduino/Genuino Uno’
Program size: 4 218 bytes (used 13% of a 32 256 byte maximum) (0,85 secs)
Minimum Memory Usage: 448 bytes (22% of a 2048 byte maximum)

Tout ceci est purement théorique

Et le code:

/*
 Consommation de bytes:
 Méthode
 int maxtemps[124][10]= {
 {1,0,0,0,0,0,0,0,1,1}, //temps 0
 = (124 * 10)*2 = 2480
 Program size: 4 828 bytes (used 15% of a 32 256 byte maximum) (0,53 secs)
 Minimum Memory Usage: 2664 bytes (130% of a 2048 byte maximum)
 ----------------------------------------------------------------------
 Méthode
 word maxtemps[]= {                                                    // Tableau à qu'une seule dimension parceque usage des bites du word
 (B10*256) + B00000011, //temps 0                                  // Utilisation de la notation en bits (0b) pour faciliter la visibilité
 = 124 *2 = 248
 Compiling 'ARDFR_Hangarber_ProblCodeB' for 'Arduino/Genuino Uno'
 Program size: 4 218 bytes (used 13% of a 32 256 byte maximum) (0,85 secs)
 Minimum Memory Usage: 448 bytes (22% of a 2048 byte maximum)
 
 Tout ceci est purement théorique 
*/

// definition

int LED_R1 = 4;
int LED_Rm2 = 5;
int LED_R3 = 6;
int LED_R4 = 7;
int LED_B1 = 8;
int LED_B2 = 9;
int LED_Bm3 = 10;
int LED_B4 = 11;
int LED_J1 = 3;
int LED_J2 = 12;

word maxtemps[]= {                                           // Tableau à qu'une seule dimension parceque usage des bites du word

0b1000000011, //temps 0
0b1110000011, //temps 1
0b1111000011, //temps 2
0b0111100011, //temps 3
0b0001111011, //temps 4
0b0000111111, // temps 5
0b0000011111, // temps 6
0b0000000111, // temps 7
0b0000000000, // temps 8
0b0000000011, // temps 9
0b0000000000, // temps 10

// texte en morse

0b1001100111, // temps 11
0b1001100111, // temps 12
0b1001100111, // temps 13
0b1001100111, // temps 14
0b1001100111, // temps 15
0b1001100111, // temps 16
0b1001100111, // temps 17
0b1001100111, // temps 18
0b1001100111, // temps 19
0b1001100111, // temps 20

0b0000000011, // temps 21
0b0000000011, // temps 22


0b1001100111, // temps 23
0b1001100111, // temps 24
0b1001100111, // temps 25


0b0000000011, // temps 26
0b0000000011, // temps 27
0b0000000011, // temps 28
0b0000000011, // temps 29


0b1001100111, // temps 30
0b1001100111, // temps 31
0b1001100111, // temps 32
0b1001100111, // temps 33
0b1001100111, // temps 34
0b1001100111, // temps 35
0b1001100111, // temps 36
0b1001100111, // temps 37
0b1001100111, // temps 38
0b1001100111, // temps 39

0b0000000011, // temps 40
0b0000000011, // temps 41

0b1001100111, // temps 42
0b1001100111, // temps 43
0b1001100111, // temps 44
0b1001100111, // temps 45
0b1001100111, // temps 46
0b1001100111, // temps 47
0b1001100111, // temps 48
0b1001100111, // temps 49
0b1001100111, // temps 50
0b1001100111, // temps 51

0b0000000011, // temps 52
0b0000000011, // temps 53

0b1001100111, // temps 54
0b1001100111, // temps 55
0b1001100111, // temps 56
0b1001100111, // temps 57
0b1001100111, // temps 58
0b1001100111, // temps 59
0b1001100111, // temps 60
0b1001100111, // temps 61
0b1001100111, // temps 62
0b1001100111, // temps 63


0b0000000011, // temps 64
0b0000000011, // temps 65
0b0000000011, // temps 66
0b0000000011, // temps 67

0b1001100111, // temps 68
0b1001100111, // temps 69
0b1001100111, // temps 70

0b0000000011, // temps 71
0b0000000011, // temps 72

0b1001100111, // temps 73
0b1001100111, // temps 74
0b1001100111, // temps 75

0b0000000011, // temps 76
0b0000000011, // temps 77

0b1001100111, // temps 78
0b1001100111, // temps 79
0b1001100111, // temps 80
0b1001100111, // temps 81
0b1001100111, // temps 82
0b1001100111, // temps 83
0b1001100111, // temps 84
0b1001100111, // temps 85
0b1001100111, // temps 86
0b1001100111, // temps 87


0b0000000011, // temps 88
0b0000000011, // temps 89
0b0000000011, // temps 90
0b0000000011, // temps 91

0b1001100111, // temps 92
0b1001100111, // temps 93
0b1001100111, // temps 94

0b0000000011, // temps 95
0b0000000011, // temps 96

0b1001100111, // temps 97
0b1001100111, // temps 98
0b1001100111, // temps 99

0b0000000011, // temps 100
0b0000000011, // temps 101

0b1001100111, // temps 102
0b1001100111, // temps 103
0b1001100111, // temps 104


0b0000000011, // temps 105
0b0000000011, // temps 106
0b0000000011, // temps 107
0b0000000011, // temps 108


0b1001100111, // temps 109
0b1001100111, // temps 110
0b1001100111, // temps 111

0b0000000011, // temps 112
0b0000000011, // temps 113

0b1001100111, // temps 114
0b1001100111, // temps 115
0b1001100111, // temps 116
0b1001100111, // temps 117
0b1001100111, // temps 118
0b1001100111, // temps 119
0b1001100111, // temps 120
0b1001100111, // temps 121
0b1001100111, // temps 122
0b1001100111 // temps 123
};


void setup() {
 pinMode(LED_R1, OUTPUT);
 pinMode(LED_Rm2, OUTPUT);
 pinMode(LED_R3, OUTPUT);
 pinMode(LED_R4, OUTPUT);
 pinMode(LED_B1, OUTPUT);
 pinMode(LED_B2, OUTPUT);
 pinMode(LED_Bm3, OUTPUT);
 pinMode(LED_B4, OUTPUT);
 pinMode(LED_J1, OUTPUT);
 pinMode(LED_J2, OUTPUT);

 digitalWrite(LED_R1, LOW);
 digitalWrite(LED_Rm2, LOW);
 digitalWrite(LED_R3, LOW);
 digitalWrite(LED_R4, LOW);
 digitalWrite(LED_B1, LOW);
 digitalWrite(LED_B2, LOW);
 digitalWrite(LED_Bm3, LOW);
 digitalWrite(LED_B4, LOW);
 digitalWrite(LED_J1, LOW);
 digitalWrite(LED_J2, LOW);

 
 Serial.begin(9600);
}
void loop() {

 for (int i = 0; i < 124; i ++)
 {

 // fonction readMax qui lit les différentes combinaisons
 readMax(i);
 delay(100);
 }
}
int readMax(int temps){
 boolean bitStatus;

 int controlPin[] = {LED_R1, LED_Rm2, LED_R3, LED_R4, LED_B1, LED_B2, LED_Bm3, LED_B4, LED_J1, LED_J2};

 // boucle
 Serial.print(String(temps) + ":\t");

 for ( int i = 9; i >= 0; i--)                                              // DE 9 à 0 parceque comptage de dits pour respecter le sens précédent
 {
 bitStatus = bitRead(maxtemps[temps], i);                               // Lecture de l'état de chaque bit du mot maxtemps[temps]
 Serial.print(bitStatus);
 digitalWrite(controlPin[i], bitStatus);                                // Ecriture de l'état du bit sur le port
 }
 Serial.println("");
}

Cordialement
jpbbricole

Oui JP - vous voyez on pense (presque) pareil sur l’usage des bit :slight_smile:

Afin d’aider ceux qui apprennent le C++ 11 — le consortium qui définit la norme s’est penché sur les types à nombre de bits fixes → Fixed width integer types

d’où la recommendation d’utiliser plutôt la notation unit16_t plutôt qu’un word et autres unsigned short

Comme mentionné à la fin de mon post #10, la notion de structure avec champs de bits permet de ne pas avoir à se soucier de la multiplication par 256 - le compilateur se chargeant d’arranger les bits en mémoire pour vous.

Note pour vous et pour moi (puisque je n’y ai pas pensé mais que ça me revient maintenant): Vous êtes obligé de faire une multiplication par 256 parce que vous utilisez les #define Arduino pour la représentation des bits.

Il ne faut pas oublier cependant que le C++ supporte (depuis la version C++14) la notation 0b comme on avait 0x pour l’hexadécimal.

l’avantage du 0b c’est qu’on n’est pas limité à 8 bits donc au lieu de

 word maxtemps[]= {                                                    // Tableau à qu'une seule dimension parceque usage des bites du word

	(B10*256) + B00000011, //temps 0                                  // Utilisation de la notation en bits (B) pour faciliter la visibilité
	(B11*256) + B10000011, //temps 1
...

on peut simplement écrire

 uint16_t maxtemps[]= {                                                    // Tableau à qu'une seule dimension parceque usage des bits des 2 octets

	0b1000000011, //temps 0,  Utilisation de la notation en bits (0b) pour faciliter la visibilité
	0b1110000011, //temps 1
...

ou alors en champs de bits avec gestion de la durée d’affichage

struct elementAffichage_t {
  uint16_t duree: 6;
  uint16_t leds: 10;
};

elementAffichage_t maxtemps[] = {
  {12,0b1110011001},
  {3, 0b0101010101},
  {1, 0b1011110000}
};

const size_t nbMaxTemps = sizeof(maxtemps) / sizeof(maxtemps[0]);

void setup() {
  Serial.begin(115200);
  Serial.print("Taille de la structure = ");
  Serial.println(sizeof(elementAffichage_t));

  for (size_t i = 0; i < nbMaxTemps; i++) {
    Serial.print("etape="); Serial.print(i);
    Serial.print(" Nb repetition= "); Serial.print(maxtemps[i].duree);
    Serial.print("\tLEDS "); Serial.println(maxtemps[i].leds, BIN);
  }
}

void loop() {}

ce qui donnera dans la console

[color=purple]Taille de la structure = 2
etape=0 Nb repetition= 12	LEDS 1110011001
etape=1 Nb repetition= 3	LEDS 101010101
etape=2 Nb repetition= 1	LEDS 1011110000
[/color]

J-M-L: Oui JP - vous voyez on pense (presque) pareil sur l'usage des bit :)

Je vais rêver cette nuit :)

J-M-L: 0b1000000011, //temps 0, Utilisation de la notation en bits (0b) pour faciliter la visibilité

Voilà un truc intéressant et surtout facilitant la vie, je voulais rester le plus possible dans le "cadre Arduino", c'est corrigé.

Cordialement jpbbricole

jpbbricole: Voilà un truc intéressant et surtout facilitant la vie, je voulais rester le plus possible dans le "cadre Arduino",

On utilise un compilateur C++ donc autant en profiter. Arduino ajoute juste une surcouche de fonctions et librairies pour rendre la vie un peu plus simple parfois..


Si vous pouviez rêver de laisser tomber les Strings quand elles ne sont pas nécessaire, ce serait super pour les nouveau venus... ;D :roll_eyes:

Merci beaucoup de toutes vos réponses hyper pointues !! ( j'avoue je ne comprends pas tout tout, heureusement que mes notions de de section S spé physique-chimie sont encore là ). Je vais reprendre tranquillement vos différentes propositions et essayer de les comprendre plutôt que de les copier bêtement mais en tout cas je pense que je préfère par soucis de lisibilité et afin de revenir y toucher assez facilement la notation en bits plutôt que haxadécimal.

Et à propos de la petite virgule manquante à la ligne 99, je l'avais bien remise, juste une petite erreur oubliée de quand je tentais de voir où ca cessait de fonctionner. et pardon j'avais oublier de dire que j'utilise une board genuino uno.

Merci encore de votre aide et agréable journée à vous.

J-M-L: Si vous pouviez rêver de laisser tomber les Strings quand elles ne sont pas nécessaire, ce serait super pour les nouveau venus... ;D :roll_eyes:

Euh non! tu est bien gentil, mais comme tu l'as dit plus haut, Arduino a rajouté une couche pour "rendre la vie un peu plus facile parfois" La "philosophie" Arduino a été crée pour rendre le C++ moins rébarbative, ce qui éloignait pas mal de gens de la programmation, dont moi. Avec tes explications d'hyper spécialiste, tu t'éloigne complètement de l'Arduino. Les gens qui viennent sur un site Arduino, s'attendent à lire de l'Arduino pas non du C++.

Cordialement jpbbricole

J'ai bien compris que vous ne saviez pas utiliser les c-strings et les bibliothèques standard stdlib.h ou string.h - ce qui est quand même important quand on veut travailler sur des petits micros-contrôleurs.

Arduino c'est fait pour apprendre et découvrir ce monde, pas obligé de rester au niveau d'entrée.

Vous remarquerez que dans le post sur le lecteur de fichier de configuration sur cartes SD je n'ai pas proposé de virer la façon dont vous analysez le fichier (on pourrait aussi faire sans la classe String) J'ai dit de les laisser tomber là où elles sont totalement inutiles.

Ensuite c'est aussi bien de savoir que plus on utilise la classe String, plus le programme a des chances d'avoir des soucis de mémoire très difficile à débugger.

Comme vous êtes loin d'être un novice mais plutôt un avancé dans vos usages, et que vous aidez les débutants avec du code, je pense que c'est important de les guider dans la bonne direction et ne pas non plus faire des trucs compliqués quand il n'y en a pas besoin.

Par exemple quand vous proposez de faire:

String logFileName = "";                                   // Nom du fichier d'enregistrement (Texte)
char logSdFileName[13];                                    //                     ""          (char)
...
    logFileName = "Sauv_01.txt";                                     // longueur max 8+3 caractères
    logFileName.toCharArray(logSdFileName, 13);

alors que l'on peut faire

char logSdFileName[] ="Sauv_01.txt";

je trouve que c'est vous qui compliquez les choses

Ou encore lors de l'accès à un fichier sur une carte SD vous proposez de faire:

File dataFile = SD.open((String)logSdFileName, FILE_READ);

Moi je dis pas la peine de passer par un objet String pour cela car la fonction sait travailler sur le tableau de caractère directement donc on peut faire simplement

File dataFile = SD.open(logSdFileName, FILE_READ);

Vous vous acharnez à grouper dans vos print toute une sortie, du genre

Serial.println("Variable X = " + String(x));

Je dis que la recommandation devrait s'écrire (plus simple à comprendre, plus rapide à exécuter et moins de mémoire utilisée)

Serial.print("Variable X = ");
Serial.println(x);

et qu'ensuite on peut même expliquer la notation avec le F("") (et pourquoi on le fait)

Serial.print(F("Variable X = ")); // voir macro F par exemple ce bon article en anglais  https://learn.adafruit.com/memories-of-an-arduino/optimizing-sram
Serial.println(x);

Voilà c'est tout ce que je dis...

Si vous n'êtes pas d'accord, c'est bien votre droit et je n'ai pas de soucis avec cela, vous pouvez coder comme vous voulez. Mais respectez mon droit à être en désaccord et recommander une autre approche qui est plus simple que ce que vous proposez à mon sens...

Avec tes explications d'hyper spécialiste, tu t'éloigne complètement de l'Arduino. Les gens qui viennent sur un site Arduino, s'attendent à lire de l'Arduino pas non du C++.

Mes explications ci dessus vous semblent compliquées?... je trouve que c'est votre code avec des String à tout va qui l'est... et il n'y a pas de langage Arduino... Arduino se programme en C++. Arduino apporte des bibliothèques et fonctions, on utilise celles que l'on souhaite ou d'autres de la communauté (par exemple SDFat est bien meilleure que la librairie SD intégrée en standard, ou AccelStepper sera mieux que la librairie standard pour les moteurs pas à pas --> c'est bien de savoir qu'on a le choix)

jpbbricole: La "philosophie" Arduino a été crée pour rendre le C++ moins rébarbative, ce qui éloignait pas mal de gens de la programmation, dont moi. Avec tes explications d'hyper spécialiste, tu t'éloigne complètement de l'Arduino. Les gens qui viennent sur un site Arduino, s'attendent à lire de l'Arduino pas non du C++.

Cordialement

Heu? Je ne voudrais pas mettre de l'essence sur le feu mais: 1/ faire du prémâché sans comprendre présente certains dangers qui peuvent amener des frustrations. 2/ C'est pourtant bien d'apprendre , de comprendre et de progresser en dépassant le prémâché 3/ L'étude de J-M-L est à tout à fait susceptible d'intéresser beaucoup de gens dont bibi ( merci J-M-L).

Cordialement, bidouilleelec