Discussion :

[mormic]

Bonjour à tous
Une question relative à la gestion de la mémoire à propos des nombres utilisés dans le programme:

J'utilise une centaine de fois dans mon programme le chiffre 8. Je me demandais s'il ne valait pas mieux utiliser une constante déclarée soit par

Code :

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

#define HUIT 8;

soit par

Code :

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

 const uint8_t huit = 8

;

J'en profite pour demander une explication sur les variables déclarées 'volatile' car sur le Net les explications sont un peu "versatile".

Merci

[Jay M]

pour répondre à la question, ça ne change rien à l'utilisation de la mémoire, l'optimiseur va faire son boulot.

Si c'est le même 8 partout, c'est mieux de le définir avec un joli nom comme constante en lui donnant un type approprié aux autres éléments de la formule dans laquelle il apparait.

Code :

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

const uint8_t nombreDeBitsDansUnOctet = 8;

Si ce sont des 8 différents, c'est quand même mieux de mettre plusieurs constantes avec des noms séparés pour la lisibilité et ça ne prendra pas plus de place sans doute si l'optimiseur fait bien son job.


En C++, le mot-clé volatile indique au compilateur qu'une variable peut être modifiée par des processus extérieurs au code en cours d'exécution, comme une tâche différentes (sur un ESP32 multi-coeur par exemple) ou une interruption. Cela empêche le compilateur d'optimiser l'accès à cette variable, en garantissant qu'elle est lue directement en mémoire chaque fois qu'elle est utilisée et écrite en mémoire chaque fois qu'elle est modifiée.

Sans `volatile`, le compilateur pourrait optimiser le code en stockant la valeur de la variable dans un registre, ce qui éviterait de relire sa valeur depuis la mémoire à chaque utilisation ou de l'écrire à chaque fois mais si la variable est modifiée, ces modifications pourraient ne pas être prises en compte, entraînant un comportement imprévisible.

[mormic]

Merci Jay M pour tes explications toujours précises et précieuses.
Pour 'volatile', c'est vraiment technique. pour mon cas, j'utilise un interrupt généré par une saisie clavier, donc ma variable est déclarée volatile.

Sur un ESP32, comment fait-on pour utiliser le deuxième coeur?

Cordialement
Michel

[Jay M]

Pour 'volatile', c'est vraiment technique. pour mon cas, j'utilise un interrupt généré par une saisie clavier, donc ma variable est déclarée volatile.

Si la variable n'est utilisée que dans l'interruption, ce n'est pas nécessaire. Si elle est utilisée à la fois dans l'ISR et dans la loop / le code principal, alors ce n'est pas suffisant. Il faut rajouter généralement une section critique qui protège l'accès à la variable.

Sur un ESP32, comment fait-on pour utiliser le deuxième coeur

Tous les ESP32 ne sont pas à 2 coeurs.

Si votre ESP32 possède deux cœurs de processeur (core 0 et core 1). Le core 0 est utilisé par des tâches du système d'exploitation temps réel (FreeRTOS) comme la gestion du Wi-Fi et du Bluetooth par exemple et avec Arduino, le code dans les fonctions setup() et loop() tourne par défaut sur le cœur 1. Vous pouvez changer cela dans l'IDE.

Pour lancer des tâches sur un coeur donné vous pouvez utiliser la fonction xTaskCreatePinnedToCore() de FreeRTOS, voici un exemple qui crée deux tâches, une sur le coeur 0, une sur le coeur 1, chacune exécutant une petite boucle qui attend un temps aléatoire et imprime un petit message.

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
// Fonction de la tâche exécutée sur le core 0
void tacheSurCore0(void *parametres) {
  Serial.print("tacheSurCore0 — Cette tâche tourne sur le core ");
  Serial.println(xPortGetCoreID());
  while (true) { // la tâche tourne de façon infinie.
    delay(random(500, 2000));
    Serial.println("La tâche 1 est en cours d'exécution...");
  }
}
 
// Fonction de la tâche exécutée sur le core 1
void tacheSurCore1(void *parametres) {
  Serial.print("tacheSurCore1 — Cette tâche tourne sur le core ");
  Serial.println(xPortGetCoreID());
  while (true) { // la tâche tourne de façon infinie.
    delay(random(500, 1000));
    Serial.println("La tâche 2 est en cours d'exécution...");
  }
}
 
void setup() {
  Serial.begin(115200);
 
  // Création de la tâche 1 sur le core 0
  xTaskCreatePinnedToCore(
    tacheSurCore0,  // Fonction de tâche
    "Tache1",       // Nom de la tâche
    10000,          // Taille de la pile
    NULL,           // Paramètres de la tâche
    1,              // Priorité de la tâche
    nullptr,        // Handle de tâche (ici on ne l'utilise pas)
    0               // Core sur lequel la tâche doit être exécutée
  );
 
  // Création de la tâche 2 sur le core 1
  xTaskCreatePinnedToCore(
    tacheSurCore1,  // Fonction de tâche
    "Tache2",       // Nom de la tâche
    10000,          // Taille de la pile
    NULL,           // Paramètres de la tâche
    1,              // Priorité de la tâche
    nullptr,        // Handle de tâche (ici on ne l'utilise pas)
    1               // Core sur lequel la tâche doit être exécutée
  );
}
 
void loop() {
  // La loop reste vide car les tâches tournent indépendamment et sont gérées par FreeRTOS
}

Attention : lorsque vous affectez des tâches au cœur 0 de l'ESP32, veillez à ne pas bloquer ce cœur avec des boucles longues ou des tâches bloquantes, car le cœur 0 est également utilisé par le système d'exploitation. Si une tâche bloque le cœur 0 trop longtemps, cela peut déclencher le watchdog et provoquer un redémarrage de l'ESP32.

un appel à delay() n'est pas bloquant au sens habituel, ça met la tâche en sommeil pendant un certain temps, donnant la main ainsi à l'OS pour faire autre chose sur ce coeur.

[mormic]

Merci beaucoup