Présentation supplémentaire de Docker pour les développeurs de logiciels ARM embarqués

Dans l’un de mes articles précédents, Introduction à Docker pour les développeurs de logiciels embarqués, nous avons commencé à discuter du rôle de Docker dans le développement de logiciels embarqués. Docker fournit un mécanisme pour configurer nos environnements de build dans un conteneur, ce qui facilite la mise en route de nouveaux développeurs. Plus important encore, Docker nous permet de créer un environnement portable à utiliser dans les DevOps embarqués comme CI/CD. L’article d’aujourd’hui explorera la configuration du compilateur Arm GCC pour compiler un projet de makefile pour les microcontrôleurs STM32.

Installer GCC-arm-none-eabi dans un conteneur Docker

La première chose que nous devons faire si nous voulons configurer un environnement de construction Arm dans Docker est de créer un Dockerfile qui configure notre environnement de construction. Pour cet exemple, je vais simplement utiliser la version d’octobre 2021 du compilateur GCC-arm-none-eabi.

Notre fichier docker comportera quatre sections :

1. L’image de base que nous utiliserons
2. Installation d’outils d’aide
3. Installer le compilateur GCC-arm-none-eabi et configurer notre chemin
4. Configuration de notre répertoire de travail

Nous utiliserons la dernière version d’Ubuntu pour notre image de base à l’aide de la commande Docker suivante :

D’ubuntu : dernier

Ensuite, il existe plusieurs outils de support sous Linux dont nous avons besoin pour télécharger, décompresser, installer et configurer le compilateur Arm. Nous allons installer ces outils dans une commande RUN comme indiqué ci-dessous :

# Téléchargez les outils de support Linux

RUN apt-get mis à jour &&

apt-get clean &&

apt-get install -y

build-essential

wget

boucle

Avant d’installer GCC-arm-none-eabi, nous voulons spécifier où l’installer. Il est courant de l’installer dans un répertoire tel que /home/dev. Nous pouvons le faire dans notre Dockerfile en utilisant la commande suivante :

# Mettre en place un répertoire d’outils de développement

WORKDIR /home/dev

AJOUTER . /home/dev

Maintenant, nous sommes prêts à installer le compilateur à l’aide de la commande suivante :

RUN wget -qO- https://developer.arm.com/-/media/Files/downloads/gnu-rm/10.3-2021.10/gcc-arm-none-eabi-10.3-2021.10-x86_64-linux.tar.bz2 | goudron -xj

Notez que je demande une version spécifique du compilateur. Lorsque vous lisez ceci, vous souhaiterez peut-être mettre à jour vers une autre version. Le compilateur étant maintenant installé, nous souhaitons configurer la variable PATH pour inclure le chemin d’accès au compilateur à l’aide de la commande suivante :

# Configurer le chemin du compilateur

CHEMIN ENV $CHEMIN :/home/dev/gcc-arm-none-eabi-10.3-2021.10/bin

Enfin, nous pouvons définir notre répertoire de travail pour notre code d’application dans le répertoire /home/app comme suit :

WORKDIR /home/app

Nous avons maintenant un Dockerfile prêt à créer notre image Docker.

Création et exécution de l’image Docker Arm GCC Docker

L’image Docker est générée à l’aide de la commande suivante sur la ligne de commande du terminal :

docker build -t beningo/GCC-arm .

Le résultat devrait ressembler à ce qui suit :

L’image peut maintenant être démarrée à l’aide de la commande suivante :

docker run –rm -it –privileged -v « $(PWD):/home/app » beningo/gcc-arm:latest bash

Création d’un projet de test

Le projet de microcontrôleur basé sur makefile se trouve à la racine du référentiel git avec le fichier docker. Vous pouvez également créer quelques modules c et écrire votre makefile. Vous pouvez également dire d’oublier de créer et de configurer à la place cmake ou un autre outil de construction. J’ai fait quelque chose de simple ; J’ai utilisé l’outil de génération de projet STM32 STM32CubeMx. J’ai créé Blinky et utilisé une carte STM32L475 IoT Discovery comme cible. (Je n’entrerai pas dans les détails car ils dépassent le cadre et sont faciles à faire).

STM32CubeMx permet aux développeurs de configurer facilement des cartes de développement et des projets de microcontrôleur STM32. Un développeur peut créer un projet pour divers environnements de développement tels que make, CubeIDE, Keil et IAR Embedded Workbench. Ensuite, un développeur peut simplement créer un projet STM32 pour tester cet environnement. La configuration de base serait juste exemplaire. L’astuce, cependant, est de configurer le projet pour qu’il soit basé sur un makefile. Le paramètre de projet makefile se trouve sous le gestionnaire de projet dans la section Génération de code, comme indiqué ci-dessous :

Le paramètre Toolchain / IDE est configuré pour Makefile. À partir de ce point, un exemple de projet peut être créé en cliquant simplement sur le bouton générer du code. Une fois cela fait, mon répertoire de référentiel et de projet ressemble à ce qui suit :

Notez que j’ai un fichier Makefile et un fichier .gitlab-ci.yml dans mon répertoire que vous n’auriez pas par défaut. Mon dépôt git a été configuré de cette façon pour plusieurs raisons, dont je parlerai dans un futur blog.

Compiler un projet Makefile STM32

Nous avons maintenant un conteneur Docker avec le compilateur GCC-arm-none-eabi installé et un exemple de projet STM32 de base. Dans l’image Docker, nous souhaitons accéder au répertoire racine de notre projet STM32. Pour moi, cela se fait en utilisant:

Projet cd/makefile/Blinky/

Une fois dans le répertoire, je peux utiliser le fichier make généré par STM32 pour compiler le projet en utilisant :

fait tout

La sortie résultante devrait ressembler à ceci :

Pour quitter Docker, tapez simplement EXIT.

Conclusion

C’est ça! Nous venons de créer un conteneur Docker avec les outils minimaux nécessaires pour compiler un projet pour un microcontrôleur Arm ! Nous avons vu que nous pouvions tirer parti d’un outil de génération de fournisseurs de microcontrôleurs pour lancer un projet basé sur un makefile et l’exécuter rapidement. Le lecteur devrait facilement dupliquer ce dont nous avons discuté et démarrer son environnement de construction.