Constante et variable

Version imprimable

Bonjour,

Je dois utiliser la fonction "setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b)" (bibli Adafruit Neopixel) qui n'accepte que des entiers, mais je suis obligé d'utiliser un "string" car je récupère une valeur sur un site via un "get", que je mettrai comme premier paramètre.
Il faudrait donc transformer "var" en entier et le faire pointer vers la valeur du nom de la constante, ici A101 afin d'allumer la 10eme led.

Merci
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #define A101 10 #include <Adafruit_NeoPixel.h> #define DATA_PIN_1 10 #define NUM_LEDS_1 120 Adafruit_NeoPixel pixels_1(NUM_LEDS_1, DATA_PIN_1, NEO_GRB + NEO_KHZ800); void setup() { String var=A101; pixels_1.setPixelColor(var,255, 0, 0); } void loop() { }

Bonsoir,

Si j'ai bien compris, il existe une fonction C atoi() qui fait la conversion chaîne de caractères --> entier :
Code:

1 2 3 4 5 // ... String str = "1234"; int num = atoi(str.c_str()); Serial.println(num + 5); // ...
qui affichera : 1239.

Edit : plus simplement :
Code:

1 2 3 4 5 // ... String str = "1234"; int num = str.toInt(); // cf. https://www.arduino.cc/reference/en/language/variables/data-types/string/functions/toint/ Serial.println(num + 5); // ...

28/12/2023, 10h14
Linoops

Merci pour ton retour.
A la base, je voulais transformer mon string en int, mais avec ce que tu me propose, je réalise que ce n'est pas ce que je souhaite, j'obtiens "0", ce qui est logique finalement, j'ai une valeur alphanumerique.
Je pense avoir mal pris mon problème.
J'ai une variable (var) qui prendra une valeur comprenant une lettre et 3 chiffres (A101) correspondant un emplacement à illuminer, j'ai donc définis un certain nombre d'emplacement avec "#define" afin de choisir la led à allumer (dans mon ex ce sera la 11ème led de ma bande car le 0 est pris en compte). Le soucis est qu'avec la fonction "setPixelColor" qui me permet de choisir la led à modifier comme premier paramètre (int uniquement), je n'arrive pas à lui indiquer le bon emplacement avec "var".
Il faudrait qu'une variable int prenne non pas la valeur de "var" (A101), mais la valeur de sa valeur (10) à laide des constantes déclarer.
J'espère avoir été compréhensible.

Nouvelle tentative, avec une structure Emplacement :

Code:

1
2
3
4
   struct Emplacement {
    String var; // ex. : "A101"
    int led; // ex. : 10
  };

Exemple d'initialisation d'une table :

Code:

1
2
3
4
5
6
  const Emplacement table[] {
    {"A101", 10},
    {"B204", 13},
    {"C412", 12} 
    // etc.
  };

Il faut une fonction qui cherche l'association (ex. avec "A101", la fonction renvoie 10) :

Code:

1
2
3
4
5
6
7
8
9
10
  int findLed(String var) {
    int i = 0;
    int n = sizeof(table)/sizeof(Emplacement);
 
    while (i < n && table[i].var != var) {
      i++;
    }
 
    return i < n ? table[i].led : -1; // -1 si pas trouvé
  }

exemples d'utilisation :

Code:

1
2
3
4
5
6
7
  Serial.println(findLed("A101")); // affiche 10
  Serial.println(findLed("C412")); // affiche 12
  Serial.println(findLed("xxxx")); // affiche -1, car pas trouvé
 
  // ...
  String var="A101";
  pixels_1.setPixelColor(findLed(var),255, 0, 0);

29/12/2023, 12h29
Linoops

Après test, c'est pas mal du tout, ça reduit pas mal la taille de mon code.
Par contre, j'ai l'impression que je suis limité en nombre d'éléments de la structure, je ne peux pas mettre plus d'une 50taine, sinon mon programme bug.
Peut-on contourner la limite ? Au pire je pourrais en créer plusieurs.
29/12/2023, 18h28
f-leb

Citation:

Envoyé par Linoops

Par contre, j'ai l'impression que je suis limité en nombre d'éléments de la structure, je ne peux pas mettre plus d'une 50taine, sinon mon programme bug.

Combien d'éléments en tout tu as besoin ? J'ai l'impression que c'est un problème dû au manque de mémoire. Quelle carte utilises-tu ?
29/12/2023, 18h41
Linoops

J'aurais besoin d'environ 420 éléments, j'ai fait en un seul bloc (ça ne fonctionnait pas), j'ai fait plusieurs bloc d'une 30taine d'éléments (ça ne fonctionne pas non plus).
J'ai un Uno wifi rev2, ça prend pas mal de place dans la mémoire dynamique mais pas pleine.
J'ai déclaré la structure dans un fichier .h, je ne sais pas si ça a une incidence.
29/12/2023, 19h12
edgarjacobs

Hello,

Ta carte a une mémoire de 48K, pas de quoi trop l'effrayer je pense avec une demande de 420*(5+4) (=3780) bytes. Ce serait plutot du côté du code que je me poserais des questions. Poste le code (même s'il est long), ça peut aider à t'aider.

Edit: orthographe
29/12/2023, 20h04
f-leb

Salut,

48ko de mémoire flash, mais seulement 6ko de mémoire vive SRAM pour stocker les variables...
29/12/2023, 21h19
edgarjacobs

Ooups, j'ai loupé cette information. Peut-être alors mettre les data en mémoire flash ? Je sais que c'est faisable ( F("Bonjour") ), mais jamais vu pour une structure.

Une nouvelle tentative avec PROGMEM pour forcer le stockage des constantes en mémoire flash :

Code:

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
#include <avr/pgmspace.h>
 
const char A310[] PROGMEM = "A310";
const char B312[] PROGMEM = "B312";
const char C114[] PROGMEM = "C114";
const char Z322[] PROGMEM = "Z322";
const char X438[] PROGMEM = "X438";
 
const char *const element_table[] PROGMEM = { A310, B312, C114, Z322, X438 };
const PROGMEM uint16_t led_table[]        = { 10,   14,   45,   24,   12 };
 
void setup() {
  Serial.begin(9600);
 
  // essais
  String var = "Z322";
  Serial.println(findLed(var)); // affiche 24
 
  var = "A000";
  Serial.println(findLed(var)); // affiche -1 car A000 n'existe pas
}
 
void loop() {
  //
}
 
  int findLed(String var) {
    int n = sizeof(led_table) / sizeof(uint16_t);
    char buffer[5];
 
    for (int i = 0; i < n; i++) {
      strcpy_P(buffer, (char *)pgm_read_ptr(&(element_table[i])));
      if (strcmp(buffer, var.c_str()) == 0) {
        return pgm_read_word_near(led_table + i);
      }
    }
    return -1;
  }

Je ne suis pas sûr que ce soit la bonne stratégie avec 420 éléments, mais bon...:aie:

vu que tous les codes ont la même taille, jouer avec une structure que l'on met en flash serait plus simple

à tester ici

https://wokwi.com/projects/385550360512004097

le code:

Code:

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
 
struct Correspondance {
  char nom[5]; // une lettre et 3 chiffres (eg A101) plus le caractère nul
  uint16_t valeur;
};
 
const Correspondance tableauDesCorrespondances[] PROGMEM {
  {"A310", 10},
  {"B312", 14},
  {"C114", 45},
  {"Z322", 24},
  {"X438", 12},
};
 
int32_t trouver(const char* texte) {
  if (strlen(texte) != 4) return -1;
  for (const Correspondance& c : tableauDesCorrespondances) {
    if (strcmp_P(texte, c.nom) == 0) return pgm_read_word_near(&(c.valeur));
  }
  return -1;
}
 
void setup() {
  Serial.begin(115200);
  Serial.println(trouver("A310"));        // 10
  Serial.println(trouver("C114"));        // 45
  Serial.println(trouver("X438"));        // 12
  Serial.println(trouver("Bonjour"));     // -1 (texte trop long)
  Serial.println(trouver("Z654"));        // -1 (pas dans la liste)
}
 
void loop() {}

parcourir 420 éléments peut prendre du temps, donc il faudrait sans doute une stratégie de hash pour trouver plus vite la correspondance (stocker dans l'ordre alphabétique au moins)