Macros Arduino : un guide complet pour les maîtriser avec des exemples

  • Les macros dans Arduino vous permettent d'optimiser le code et la mémoire avant la compilation.
  • L'utilisation de #define vous permet de créer des fonctions, des constantes et des structures adaptatives.
  • Les macros avancées vous permettent de concaténer des identifiants et d'accéder à PROGMEM.
  • L’utilisation disciplinée des macros améliore l’efficacité sans sacrifier la lisibilité.
Isaac

5 Minutes

Cœurs Arduino Zephyr OS bêta-1

Arduino a révolutionné le monde de l'électronique grâce à la facilité avec laquelle des prototypes et des projets fonctionnels peuvent être créés. Cependant, pour ceux qui souhaitent pousser leur programmation un peu plus loin et optimiser les ressources, garder le code propre et gagner en efficacité, le macros devenir un outil clé.

Dans cet article, nous allons approfondir l’utilisation de macros dans Arduino: ce qu'ils sont, comment ils sont utilisés, leurs avantages et leurs limites. Et nous y parviendrons en rassemblant les informations les plus complètes et les plus utiles provenant des meilleures ressources disponibles en ligne, réécrites de manière claire et moderne pour être vraiment pratiques.

Que sont les macros dans Arduino ?

Les macros sont des directives de préprocesseur en C/C++ qui vous permettent de remplacer du texte avant que le code ne soit compilé. Au lieu d'exécuter des instructions comme une fonction traditionnelle, une macro fonctionne en remplaçant des parties du texte source, qui a un impact direct sur la façon dont le code binaire final est généré.

Le préprocesseur Il s'exécute avant la compilation réelle et est responsable de l'application de ces substitutions. Dans Arduino, cela permet à partir de définir des constantes, inclure des fichiers de manière conditionnelle ou même créer de petits fonctionnalités en ligne qui permettent de gagner du temps et de la mémoire.

Exemple de base : une définition comme #define LED_PIN 13 provoque le remplacement automatique de tout le code LED_PIN par 13 avant de compiler.

Cela peut paraître trivial, mais cela offre une un moyen puissant d'écrire du code plus flexible et plus maintenable.

Avantages de l'utilisation des macros

L'implémentation de macros dans les projets Arduino peut offrir un certain nombre d'avantages spécifiques :

  • Améliorer la lisibilité du code : En réutilisant des noms symboliques, il est plus facile de comprendre le but de chaque élément.
  • Optimisez les performances : En ne générant pas d’appels de fonction, les macros peuvent exécuter les opérations plus rapidement.
  • Réduire l’utilisation de la RAM : particulièrement utile sur les cartes à ressources limitées, telles que Arduino UNO.
  • Permet des adaptations conditionnelles : Il est possible de compiler différents fragments de code en fonction du type de carte Arduino utilisé.

Macros de base : Utilisation de #define

Directif #define C'est le plus utilisé. Il est utilisé à la fois pour définir des valeurs constantes comme pour créer des fonctions automatiques injectées au moment de la pré-compilation.

Exemple 1 : définir une broche

#define PINLED 13

void setup() {
  pinMode(PINLED, OUTPUT);
}

void loop() {
  digitalWrite(PINLED, HIGH);
  delay(500);
  digitalWrite(PINLED, LOW);
  delay(500);
}

Exemple 2 : Macro comme fonction en ligne

int itemCounter = 0;
#define COUNT_ITEM() do { itemCounter++; } while(0)

void setup() {
  Serial.begin(9600);
  COUNT_ITEM();
  COUNT_ITEM();
}

void loop() {
  Serial.println(itemCounter);
}

Comme vous pouvez le voir, l'utilisation du modèle faire { … } pendant que(0) garantit que la macro se comporte en toute sécurité même si elle est utilisée dans des structures conditionnelles.

Opérateur ## et concaténation de macros

L'opérateur ## est un outil de préprocesseur puissant. qui permet de concaténer des identifiants. Ceci est très utile lorsque vous souhaitez générer des noms de variables de manière dynamique.

Exemple pratique:

#define GENERAR_VARIABLE(no) \
  int var##no = no;

void setup() {
  GENERAR_VARIABLE(3); // crea int var3 = 3
}

Avertissement important : Cet opérateur n'est pas compatible avec tous les modèles de cartes Arduino de la même manière. Par exemple, cela peut bien fonctionner sur un Uno ou un Esplora, mais échouer sur un Mega. De plus, vous ne pouvez pas imbriquer la création de macro dans d'autres macros en utilisant ## directement.

Macros et économie de mémoire

L’un des principaux avantages de l’utilisation de macros dans Arduino est la économiser la RAM. Arduino a une capacité limitée, donc le chargement de chaînes de texte directement dans la RAM peut devenir un problème important.

Une technique avancée pour éviter cela consiste à utiliser FORCE_INLINE et charger des chaînes à partir de la mémoire du programme (PROGMEM) :

#include <HardwareSerial.h>
#define MYSERIAL Serial
#define FORCE_INLINE __attribute__((always_inline)) inline

FORCE_INLINE void printFromFlash(const char *str) {
  char ch = pgm_read_byte(str);
  while (ch) {
    MYSERIAL.write(ch);
    ch = pgm_read_byte(++str);
  }
}

#define SERIAL_LOG(x) (MYSERIAL.print(x))
#define SERIAL_LOGLN(x) (MYSERIAL.println(x))

L'utilisation de ces macros peut faire la différence entre un projet qui fonctionne ou non, en particulier dans les applications avec des écrans ou plusieurs capteurs.

Macros combinées avec des fonctions

Les macros peuvent également faciliter l'appel de fonctions de manière dynamique, en fonction d'un type passé en paramètre. Un exemple clair et assez graphique est :

#define FUNC_LENTA(tipo) \
  { funcion_##tipo##_lenta(); }

#define FUNC_RAPIDA(tipo) \
  { funcion_##tipo##_rapida(); }

void funcion_caminar_lenta() {
  Serial.println("Andando despacio");
}

void funcion_caminar_rapida() {
  Serial.println("Andando rápido");
}

void setup() {
  Serial.begin(9600);
  FUNC_LENTA(caminar);
}

void loop() {
  FUNC_RAPIDA(caminar);
}

Grâce à l'opérateur ## et aux macros, nous pouvons éviter de répéter les structures et centraliser la logique dynamique..

Macros avec paramètres de sortie

Il est également possible d'utiliser des macros pour encapsuler de petits objets ou des conversions :

#define BOOL_OUT() (bool){false}
#define NUM_OUT(a,b) (float){a+b}
#define STR_OUT(msg) (String){msg}

void loop() {
  Serial.println(BOOL_OUT());
  Serial.println(NUM_OUT(1.2, 3.4));
  Serial.println(STR_OUT("Mensaje"));
}

Bonnes pratiques et précautions avec les macros

L’utilisation excessive ou négligente des macros peut entraîner erreurs difficiles à déboguer. Par exemple, en effectuant des substitutions incorrectes ou en définissant des noms qui entrent en conflit avec des noms dans des bibliothèques externes.

Quelques règles de base pour éviter les problèmes :

  • Évitez les espaces inutiles ou les sauts de ligne dans la macro.
  • Ne pas inclure de commentaires dans des macros complexes qui utilisent plusieurs lignes.
  • Utilisez des noms uniques ou avec des préfixes (comme le nom du projet) pour éviter les conflits.
  • Remplacer les macros par des constantes ou des fonctions réelles chaque fois que possible. Le C++ moderne permet des alternatives plus propres et plus sûres.

D’un autre côté, l’utilisation excessive de macros peut réduire la clarté du code. L’objectif devrait être d’améliorer l’efficacité et la modularité sans compromettre la maintenabilité.

Directives conditionnelles et compilation adaptative

L’une des fonctionnalités les plus pratiques dans les projets évolutifs est l’utilisation de macros pour générer du code de manière conditionnelle, quelque chose de très utile lorsque vous souhaitez que le même croquis fonctionne sur différentes cartes.

Exemple typique :

#ifdef ARDUINO_MEGA
  #define LEDPIN 53
#else
  #define LEDPIN 13
#endif

Il est également utile pour contrôler le débogage ou afficher les messages du compilateur avec #message pragmatique ou même générer des erreurs dans certaines conditions avec #Erreur.

Macros internes du compilateur

Le préprocesseur GCC pour AVR (utilisé dans Arduino) comprend plusieurs macros spéciales qui fournissent des informations système, très utile pendant le développement :

  • __LIGNE__: numéro de ligne actuel.
  • __DÉPOSER__: nom du fichier courant.
  • __HEURE__ et __DATE__: heure et date de compilation.
  • __func__: nom de la fonction en cours.

Ils permettent le contrôle des versions, les structures de journaux et facilitent la maintenance et le traçage des erreurs sans envahir le code principal.

Les macros offrent un moyen puissant et flexible de structurer les projets Arduino. Ils permettent de définir des constantes, économiser de la mémoire, adapter le code en fonction de l'environnement d'exécution et créez des blocs réutilisables sans dupliquer les lignes. Bien sûr, ils nécessitent de la discipline, de la clarté et des connaissances pour éviter des erreurs subtiles ou une perte de lisibilité. Lorsqu'ils sont appliqués correctement, ils constituent un atout précieux pour les développeurs intermédiaires et avancés.