Compilation STM32 avec IAR via GNU Make : Automatisation pour CI/CD

Automatisation des builds de firmware STM32 avec IAR et GNU Make pour CI/CD

Intégrer le compilateur IAR avec GNU Make permet une automatisation de niveau industriel pour le développement de systèmes embarqués, en abandonnant la dépendance à l'IDE et en fluidifiant les pipelines CI/CD. Cette approche vous permet de compiler le firmware des microcontrôleurs STM32 directement en ligne de commande, garantissant reproductibilité, scalabilité et intégration fluide avec les systèmes d'intégration continue.

Décomposition de la chaîne d'outils IAR et de ses utilitaires en ligne de commande

IAR Embedded Workbench est livré avec des outils en ligne de commande qui gèrent chaque étape de la compilation et du linkage. Les composants clés incluent :

• iasmarm.exe — Assembleur ARM.
• iccarm.exe — Compilateur C/C++ pour ARM.
• ilinkarm.exe — Linker.
• ielftool.exe — Utilitaire pour générer des fichiers binaires (HEX, BIN).

Ces outils sont invoqués en arrière-plan par l'IDE lors des builds graphiques, mais vous pouvez les appeler directement dans des scripts. En examinant le journal de build de l'IDE IAR, vous pouvez identifier les drapeaux en ligne de commande exacts utilisés pour chaque outil. Par exemple, les options typiques pour le compilateur iccarm.exe incluent --cpu=Cortex-M4, --fpu=VFPv4_sp, --debug, et des drapeaux pour désactiver les optimisations comme --no_inline ou --no_cse.

Création d'un Makefile pour IAR

L'objectif principal est de concevoir un Makefile qui invoque correctement les outils IAR avec les bons paramètres. Le script doit localiser les outils de manière flexible via la variable d'environnement IAR_PATH ou le PATH système. Voici un exemple pour définir les variables d'outils :

ifdef IAR_PATH
    CC = $(IAR_PATH)/iccarm.exe
    AS = $(IAR_PATH)/iasmarm.exe
    LD = $(IAR_PATH)/ilinkarm.exe
    ELF_TOOL = $(IAR_PATH)/ielftool.exe
else
    CC = iccarm.exe
    AS = iasmarm.exe
    LD = ilinkarm.exe
    ELF_TOOL = ielftool.exe
endif

Les sections essentielles du Makefile incluent :

• Drapeaux de compilation (CFLAGS) : Options spécifiques à IAR comme la sélection du cœur cible, les réglages FPU et les infos de debug.
• Drapeaux d'assembleur (ASFLAGS) : Paramètres pour gérer les fichiers assembleur.
• Drapeaux de linker (LDFLAGS) : Options du linker, incluant le fichier de config (.icf) et le point d'entrée.
• Règles de build : Cibles pour compiler les fichiers sources (.c, .s) en fichiers objets (.o) et les linker en exécutable (.out).

Configuration du compilateur et options clés

Pour des builds fiables, il faut maîtriser les options du compilateur IAR. Les drapeaux courants pour un projet STM32F407 (Cortex-M4) typique incluent :

• --cpu=Cortex-M4 : Spécifie le cœur CPU cible.
• --fpu=VFPv4_sp : Active l'unité de calcul en virgule flottante.
• --endian=little : Définit l'ordre des octets.
• -e : Active les extensions du langage C IAR.
• --debug : Ajoute les informations de debug.
• Contrôles d'optimisation comme --no_inline pour désactiver les fonctions inline.

Ces options sont regroupées dans la variable COMPILE_IAR_OPT de votre Makefile. Vous pouvez aussi supprimer des avertissements spécifiques du compilateur avec --diag_suppress.

Processus de linkage et génération des artefacts finaux

Le linker IAR (ilinkarm.exe) combine les fichiers objets à l'aide d'un script de linker (.icf) qui mappe les sections vers la mémoire du microcontrôleur. Options clés du linker :

• --config $(LDSCRIPT) : Pointe vers le fichier de config du linker.
• --entry __iar_program_start : Définit le point d'entrée du programme.
• --semihosting : Active le semihosting pour le debug.
• --map $(BUILD_DIR)/$(TARGET).map : Génère une carte mémoire.

Une fois le fichier .out prêt, ielftool.exe le convertit en formats flashables :

• --ihex pour les fichiers HEX.
• --bin pour les images binaires.

Intégration CI/CD et avantages clés

Utiliser GNU Make avec IAR offre des avantages révolutionnaires pour le développement embarqué professionnel :

• Automatisation : Déclenchez les builds automatiquement sur les serveurs CI/CD (ex. : Jenkins, GitLab CI) sans étapes manuelles.
• Reproductibilité : Les Makefiles assurent des résultats cohérents sur toutes les machines, contrairement aux réglages IDE qui varient selon l'environnement.
• Scalabilité : Ajoutez de nouvelles configs de build (ex. : pour différents modèles de dispositifs) en modifiant quelques lignes, sans retoucher des dizaines de setups IDE.
• Indépendance IDE : Utilisez n'importe quel éditeur ou IDE — pas de verrouillage sur IAR Embedded Workbench.
• Comparaison de compilateurs : Passez facilement d'un compilateur à l'autre (ex. : IAR et GCC) pour vérification croisée et chasse aux bugs.

Guide d'implémentation étape par étape

• Installez IAR Embedded Workbench et assurez-vous que les outils en ligne de commande sont dans le PATH ou définissez la variable IAR_PATH.
• Analysez votre projet IAR existant (ex. : issu de STM32CubeMX) pour extraire les drapeaux du compilateur du journal de build de l'IDE.
• Créez un Makefile de base avec les variables d'outils, drapeaux de compilation/linkage et règles de build.
• Ajustez le script de linker (.icf) pour votre plateforme cible si nécessaire.
• Testez le build en ligne de commande, en vérifiant les sorties HEX/BIN.
• Intégrez-le à CI/CD en ajoutant un appel make à votre pipeline.

Points clés à retenir

• Automatisation des builds : GNU Make automatise entièrement la compilation de firmware IAR, éliminant le travail manuel dans l'IDE.
• Flexibilité de config : Gérez facilement plusieurs variantes de build via Makefile — essentiel pour les projets multi-produits.
• Intégration CI/CD : S'intègre parfaitement à l'intégration/livraison continue, accélérant les cycles de développement.
• Indépendance des outils : Libère les développeurs des IDE spécifiques, boostant la flexibilité du workflow.
• Amélioration de la qualité du code : Les builds multi-compilateurs révèlent des bugs cachés et améliorent la portabilité.

— Editorial Team