Constante et variable

**Linoops** · 27/12/2023, 15h50

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 :

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

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() {
 
}

**f-leb** · 27/12/2023, 21h00

Bonsoir,

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

Code :

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

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 :

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

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);
// ...

**Linoops** · 28/12/2023, 10h14

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.

**f-leb** · 28/12/2023, 11h28

Nouvelle tentative, avec une structure Emplacement :

Code :

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

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

Exemple d'initialisation d'une table :

Code :

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

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 :

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

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 :

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

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);

**Linoops** · 29/12/2023, 12h29

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.

**f-leb** · 29/12/2023, 18h28

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 ?

**Linoops** · 29/12/2023, 18h41

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.

**edgarjacobs** · 29/12/2023, 19h12

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

**f-leb** · 29/12/2023, 20h04

Salut,

48ko de mémoire flash, mais seulement 6ko de mémoire vive SRAM pour stocker les variables...

**edgarjacobs** · 29/12/2023, 21h19

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.

**f-leb** · 29/12/2023, 22h00

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

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
#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...

**Jay M** · 30/12/2023, 15h59

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 :

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
 
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)

Constante et variable

Arduino

Discussions similaires

Partager

Partager