LOCODUINO

Ces tableaux qui peuvent nous simplifier le développement Arduino

Le 28 octobre 2017. Par : bobyAndCo

Retourner à l'article

Vous répondez à :

18 Messages

• Ces tableaux qui peuvent nous simplifier le développement Arduino 29 octobre 2017 01:28, par Jean-Michel Bapt

  Bonjour,

  Il y a-t-il un avantage à déclarer une constante par l’intermédiaire d’un directive (« #define NBRE_AIGUILLAGE 16 ») plutôt que que par la méthode "habituelle" (« const byte nbre_aiguillages = 16 ; ») puisque dans les deux cas, il faut aller dans le programme pour modifier la valeur désirée (passer de 16 à 17 comme dans votre exemple) ?

  Par ailleurs, dans le programme exemple qui utilise la méthode "habituelle", il y a un bug potentiel car la constante déclarée en entête n’est pas utilisée dans la boucle void{} : la valeur est écrite "en dur" (« for (int i = 0 ; i < 16 ; i++) »)

  En tous cas, merci pour vos articles forts intéressants.

  Répondre

  • Ces tableaux qui peuvent nous simplifier le développement Arduino 29 octobre 2017 05:16, par bobyAndCo

     

    Merci aussi pour vos questions fort intéressantes également.

    Il y a-t-il un avantage à déclarer une constante par l’intermédiaire d’un directive (« #define NBRE_AIGUILLAGE 16 ») plutôt que que par la méthode "habituelle" (« const byte nbre_aiguillages = 16 ; »)

    Utiliser les constantes de préprocesseurs #define est très utilisé en programmation C/C++. Regardez par exemple comment sont écrites les bibliothèques.

     

    Cependant, quand je lis la page du site Arduino, je constate qu’ils déconseillent l’utilisation de #define au profit de ce que vous appelez justement la méthode habituelle.

    https://www.arduino.cc/en/Reference...

     

    Jean-Luc avait écrit un petit article sur les constantes :
    http://www.locoduino.org/spip.php?a...
    où il mettait en garde sur le choix judicieux des noms pour éviter toute déconvenue. Il semble bien que ce soit pour cela que le site Arduino en déconseille l’usage.

     

    Personnellement, je trouve tellement pratique leur utilisation. J’utilise un nom en majuscule qui est une convention et qui me permet de les identifier rapidement dans le code.

    S’il y a au moins un avantage, c’est que je suis certain d’avoir bien déclaré une constante alors que je peux oublier le préfix const lors de la déclaration d’une variable qui devrait justement l’être en constante.

    Par ailleurs, dans le programme exemple qui utilise la méthode "habituelle", il y a un bug potentiel car la constante déclarée en entête n’est pas utilisée dans la boucle void : la valeur est écrite "en dur" (« for (int i = 0 ; i < 16 ; i++) »)

    Je ne pense pas qu’il y ait de bug potentiel en écrivant cela. J’ai déclaré et initialisé une variable en dehors de toute fonction (setup, loop ou autres) const byte nbre_aiguillages = 16;

     

    C’est donc une variable globale. Je l’utilise ensuite à la ligne du dessous et c’est tout. Ce n’est certes pas optimal en termes de programmation (ça se voulait être l’exemple à ne pas suivre) mais cela ne constitue en rien un bug potentiel.

     

    Bien amicalement,

    Christophe

    Répondre

    • Ces tableaux qui peuvent nous simplifier le développement Arduino 29 octobre 2017 10:29, par Jean-Michel Bapt

      Je suis d’accord avec vous, le mot "bug" est sans doute mal approprié, ce que je voulais dire est que cet "exemple à ne pas suivre" est représentatif du comportement inattendu possible d’un programme (je modifie une constante mais le résultat final ne change pas alors que ça devrait, c’est étrange...).
      Bien amicalement.
      Jean-Michel

      Répondre

• Ces tableaux qui peuvent nous simplifier le développement Arduino 29 octobre 2017 10:37, par bobyAndCo

  je modifie une constante mais le résultat final ne change pas alors que ça devrait, c’est étrange…

  Oh là, je ne vous suis plus du tout. A aucun moment je n’ai essayé de "modifier" la valeur d’une variable déclarée et initalisée comme constante. D’ailleurs, le compilateur ne laisserait pas passer.

   

  Christophe

  Répondre

  • Ces tableaux qui peuvent nous simplifier le développement Arduino 29 octobre 2017 14:30, par bricoleau

    Bonjour

    Au nom de la communauté, merci pour ce très bon article à destination des débutants.

    ---

    Je peux essayer d’apporter un éclairage sur #define vs const :

    • #define permet de substituer un nom par une valeur partout dans le code, lors de la précompilation.

    • const tel qu’envisagé ici, est assez similaire : une variable globale déclarée en const n’occupe aucun espace en RAM. Le compilateur lui substitue sa valeur partout où elle est utilisée. Au final cela revient presque au même que #define, sauf qu’avec const la valeur est mieux définie car elle est typée. Le compilateur va vérifier qu’elle est bien utilisée conformément à son type, et générer une erreur si ce n’est pas le cas.

    ---

    A mon sens, #define ne devrait être utilisé que pour inclure/exclure des portions de code facultatives, typiquement un #define debug qui permet d’activer ou non des traces dans le programme.

    ---

    Enfin, la petite astuce que j’utilise souvent pour la taille des tableaux :

    int tableau = {1, 2, 3, 4, 5};
    const size_t NB_ELEMENTS = sizeof(tableau) / sizeof(int);

    NB_ELEMENTS est calculé par le compilateur, qui substitue ensuite la référence par sa valeur, partout où elle apparaît dans le code.
    Cela ne pèse donc rien dans le résultat compilé, et on peut ajouter un élément dans le tableau sans avoir aucune autre modif de code ailleurs ;-)

    Répondre

    • Ces tableaux qui peuvent nous simplifier le développement Arduino 29 octobre 2017 18:58, par bobyAndCo

      Merci aussi pour vos encouragements. Vous me semblez avoir des choses très intéressantes à partager également. Pourquoi ne pas vous aussi rédiger quelques contributions ???

       

      Au travers de l’exemple que vous apportez sur la taille des tableaux, je relève l’extraordinaire richesse des langages C et C++. Avec les quels tout je crois est possible mais l’est aussi souvent par plusieurs chemins différents. C’est ce qui le rend difficile à appréhender mais avec un peu de pratique, on peut "jouer avec" comme on joue avec des mots ou des concepts. L’objectif étant de trouver la réponse la plus efficiente. Il faut chercher à en comprendre les subtilités et ainsi les maitriser. Et merci au compilateur qui nous aide dans de nombreux cas à trouver nos erreurs.

       

      Bien amicalement
      Christophe

      Répondre

• Ces tableaux qui peuvent nous simplifier le développement Arduino 30 octobre 2017 09:48, par bobyAndCo

   

  J’ai fait un ajout dans l’article concernant les énumérations et les index de tableaux.

  Répondre

• Ces tableaux qui peuvent nous simplifier le développement Arduino 21 février 2018 10:30, par David

  Bonjour,

  je cherche simplifier mon code pour gérer plusieurs sorties.

  je m’explique en écrivant mes sorties comme ça : int Sortie[] = {3, 4, 5, 6, 7}; j’aimerais pouvoir leurs donner l’info digitalWrite(Sortie [],HIGH); mais que l’info "HIGH" ou "LOW" de mes sorties soient gérée avec un tableau char allumage[8]{1,0,0,1,0,0,0,1};

  comme ça je pourrai réduire le nombre de ligne pour un chenillard à led

  J’espère que ce soit compréhensible.

  Merci de votre aide

  David Rey

  Répondre

• Ces tableaux qui peuvent nous simplifier le développement Arduino 21 février 2018 12:02, par bobyAndCo

  Bonjour David,

   

  Attention tout d’abord, un tableau se déclare et s’initialise ainsi : int sortie[] = {3, 4, 5, 6, 7};. Essayez de ne pas mettre de majuscule à la première lettre de vos variables (Sortie) ce que l’on réserve par convention pour les distinguer des classes ou de structures par exemple.

   

  Pour activer (ou désactiver) toutes les broches facilement, vous pouvez en effet écrire une boucle :

   

  const int nbre_broches = 5;
  int sortie[nbre_broches] = {3, 4, 5, 6, 7};
  for (int i = 0; i < nbre_broches; i++) {
    pinMode(sortie[i], OUTPUT);
    digitalWrite(sortie[i], LOW);
  }

   

  Vous pouvez stocker l’état de vos broches comme vous le proposez dans un autre tableau byte allumage[5] ; (5 et non 8, autant d’état possible que de broches). Vous ajouterez alors :

   

  const int nbre_broches = 5;
  int sortie[nbre_broches] = {3, 4, 5, 6, 7};
  byte allumage[nbre_broches];
  
  void setup() {
    for (int i = 0; i < nbre_broches; i++) {
      pinMode(sortie[i], OUTPUT);
      digitalWrite(sortie[i], LOW);
      allumage[i] = 0;
    }
  }

   

  Si vous voulez accéder à l’état de la broche 6 par exemple, vous écrirez ceci : byte testEtatBroche = allumage[3]; (3 étant l’index de la broche 6). Par exemple :

   

  digitalWrite(sortie[3], HIGH);
  allumage[3] = 1;

   

  ou mieux :

   

  allumage[3] = 1;
  digitalWrite(sortie[3, allumage[3]);

   

  Mais vous pouvez, et c’est mieux, utiliser un tableau à 2 dimensions qui va contenir le numéro de la broche et son état comme ceci :

   

  const int nbre_broches = 5;
  int sortie[nbre_broches][2] = {{3, LOW}, {4, LOW}, {5, HIGH}, {6, LOW}, {7, HIGH}};

   

  L’utilisation se fera par exemple comme ceci :

   

  const int nbre_broches = 5;
  int sortie[nbre_broches][2] = {{3, LOW}, {4, LOW}, {5, HIGH}, {6, LOW}, {7, HIGH}};
  
  void setup() {
    for (int i = 0; i < nbre_broches; i++) {
      pinMode(sortie[i][0], OUTPUT);
      digitalWrite(sortie[i][0], sortie[i][1]);
    }
  }

   

  Mais vous parliez de chenillard, n’est pas quelque chose comme ceci que vous souhaitez ?

   

  const int nbre_broches = 5;
  const int nbre_etats = 8;
  
  int sortie[nbre_broches] = {3, 4, 5, 6, 7};
  byte allumage[nbre_etats] = {1, 0, 0, 1, 0, 0, 0, 1};
  
  void setup() {
    for (int i = 0; i < nbre_broches; i++) {
      pinMode(sortie[i], OUTPUT);
      digitalWrite(sortie[i], LOW);
    }
  }
  
  void loop() {
    for ( int i = 0; i < nbre_broches; i++) {
      for (int j = 0; j < nbre_etats; j++) {
        digitalWrite(sortie[i], allumage[j]);
        delay(100);
      }
    }
  }

   

  En espérant que cela vous aidera.

   

  Bien cordialement.

   

  Christophe

  Répondre

  • Analog 21 novembre 2019 07:43, par audouy laurent

    Bonjour,
    je ne vous vois pas utiliser de PIN analogique (A0, A..),

    chez moi ça donne pas grand chose,
    A0 = 14
    j’ai vérifié il semble que les PINs analogiques soient en fait les broches de 14 à 19 (UNO), du coup il faut une moulinette ou bien prendre l’habitude de déclarer les A par leur numéros cachés au grand public (pas cool pour partager du code)….

    Répondre

    • Analog 22 novembre 2019 08:32, par Jean-Luc

      Bon,

      Si vous aviez investigué un peu plus, vous auriez constaté que A0,A1, ... , An, sont des constantes numériques définies pour chaque Arduino. Pour le Uno par exemple, on trouve :

      #define PIN_A0   (14)
      #define PIN_A1   (15)
      #define PIN_A2   (16)
      #define PIN_A3   (17)
      #define PIN_A4   (18)
      #define PIN_A5   (19)
      #define PIN_A6   (20)
      #define PIN_A7   (21)
      
      static const uint8_t A0 = PIN_A0;
      static const uint8_t A1 = PIN_A1;
      static const uint8_t A2 = PIN_A2;
      static const uint8_t A3 = PIN_A3;
      static const uint8_t A4 = PIN_A4;
      static const uint8_t A5 = PIN_A5;
      static const uint8_t A6 = PIN_A6;
      static const uint8_t A7 = PIN_A7;

      Par conséquent, le code donné par bobyAndCo qui consiste à initialiser un tableau avec les pins pour le parcourir, ne nécessite aucun changement si ce n’est initialiser le tableau avec les pins qui vous intéresse, comme ceci par exemple :

      int sortie[nbre_broches] = {3, 4, 5, 6, A0, A1, A5};

      Répondre

      • Analog 22 novembre 2019 09:52, par audouy laurent

        harg, c’est ma faute j’ai oublié de préciser pour un retour en écriture dans le moniteur série, sinon j’avais bien remarqué que ça ne gênait en rien le code...
        rien d’insurmontable...
        merci pour votre réactivité et votre précision.
        laurent

        Répondre

• Ces tableaux qui peuvent nous simplifier le développement Arduino 21 novembre 2019 14:01, par bobyAndCo

  Uhmm, uhmmm, je vous sens grincheux !

   

  Je propose des façons de faire qui peuvent obliger à (de petits) efforts intellectuels... ou peut-être simplement de la curiosité. Oui, pour des raisons qu’il est aisé de comprendre, j’utilise pour les broches une numérotation numérique sur laquelle il est aisé de faire des additions (i++) et non alphanumérique où c’est bien sûr plus compliqué.

   

  Vous cherchez : pin mapping arduino uno sur Google et vous trouvez immédiatement les équivalences.

   

  Maintenant, il est vrai que j’aurai aussi pu vous proposer d’utiliser des structures en C dans lesquelles on aurait pu entrer le nom A0, A1, An et son équivalent en numérique. Pas sûr que cela ait été plus compréhensible pour le plus grand nombre.

   

  Fort de votre remarque, je réfléchirai à deux fois maintenant avant de proposer quelque chose. Pour votre part, quel est le nombre de vos contributions sur Locoduino ?

  Répondre

• Ces tableaux qui peuvent nous simplifier le développement Arduino 27 décembre 2020 22:19, par Domec

  Bonjour,

  Je cherchais justement quel était le problème avec A0,...
  Débutant avec les tableaux par envie d’être plus efficace.
  Merci pour votre travail et les réponses.
  Cordialement.

  Répondre

• apprendre le langage arduino 28 janvier 2023 19:01, par salhi mohamed

  je voudrais avoir une liste exhaustive des codes codes Arduino et leurs fonctions.
  merci

  Répondre

• développement Arduino 28 janvier 2023 19:04, par salhi mohamed

  liste exhaustive des codes du langage Arduino.
  merci.

  Répondre

• Emuler touches clavier 5 décembre 2023 19:35, par ROCHE Benoit

  bonjour,
  j’utilise une matrice pour émuler des touches clavier pour PS5, sur 14 boutons je n’ai pas de souci car se n’est que des ctrl’lettre’ ou shift’lettre’
  mais pour le bouton 15 j’ai besoin de simuler un appuis long sur le ’s’, j’ai mis :
  Keyboard.press (’S’) ;
  delay(1000) ;
  Keyboard.release(’S’) ;
  delay(500) ;
  même en modifiant les temps, rien ne change.
  d’avance merci

  Répondre

• Ces tableaux qui peuvent nous simplifier le développement Arduino 5 décembre 2023 19:57, par bobyAndCo

  Bonsoir,

  Je n’ai pas le sentiment que votre demande soit liée au modélisme ferroviaire qui est la raison d’être de Locoduino. Voir en bas de cette page.

  Quoi qu’il en soit, ce n’est pas non plus un problème de tableau, donc vous n’êtes pas dans la bonne rubrique. Et vous n’êtes pas non plus un lecteur très assidu du site car vous verriez que les delay() sont source de beaucoup de maux et je suis certaine que votre problème est là. Il faut leur préférer des solutions « non bloquantes » à base de millis(). Je vous montre l’exemple que j’avais sous la main que j’ai écrit hier et qui justement utilise un tableau :

  for ( uint8_t i = 1; i < tabIdSize; i++)
  {
     if (lastHeartbeatTime[i] > 0 && millis() - lastHeartbeatTime[i] > watchdogTimeout)
     {
       // Déclencher la procédure d'erreur pour i+1
       Serial.print("Aucun signe de vie pour le satellite ");
       Serial.println(i + 1);
     }
  }

  Si vous ne voyez pas du tout de quoi je parle, contactez moi par MP et envoyez moi votre code, SAUF s’il s’agit bien d’un projet ferroviaire, auquel cas il faut poster sur le forum pour que la communauté en profite.

  Bien cordialement

  Christophe

  Répondre