Comment préparer un environnement ROS personnalisé sur la carte NVIDIA Jetson

En raison de ses capacités, la carte NVIDIA Jetson est une plateforme idéale pour installer un environnement ROS (Robot Operating System). Cependant, la configuration de ROS sur la carte peut présenter des défis, tels que des dépendances système manquantes, une compilation lente des paquets et la nécessité d'une optimisation matérielle. Dans cet article, je vous guiderai à travers un tutoriel sur la préparation d'un environnement ROS personnalisé sur la carte NVIDIA Jetson, en abordant ces problèmes et en fournissant des instructions étape par étape pour l'installation.

Pourquoi NVIDIA Jetson pour ROS ?

La carte Jetson est une série de plateformes informatiques embarquées développées par NVIDIA. Ces cartes sont spécialement conçues pour exécuter des applications d'IA et d'apprentissage profond dans des environnements aux ressources limitées. Les cartes Jetson intègrent des GPU puissants, des CPU multicœurs et des accélérateurs d'IA dédiés pour offrir des capacités de calcul hautes performances dans un format compact. Elles sont reconnues pour leur capacité à traiter et analyser efficacement les données des capteurs, à effectuer des tâches de vision par ordinateur et à exécuter des algorithmes d'IA complexes. Elles sont donc couramment utilisées dansrobotique, véhicules autonomes, drones, l'automatisation industrielle et d'autres applications d'informatique en périphérie.

Quels sont les principaux défis liés à la configuration d'un environnement ROS ?

Les développeurs peuvent rencontrer quelques problèmes courants lors de la préparation de ROS sur les cartes Jetson, tels que les suivants :

1. ROS présente plusieurs dépendances système qui doivent être installées avant de pouvoir l'utiliser. Si vous rencontrez des erreurs de compilation lors de la construction des paquets ROS, il est probable qu'une dépendance système soit manquante ou qu'il y ait une incompatibilité de version. La meilleure façon de détecter les collisions de paquets et les erreurs de compilation est d'utiliser des fichiers Docker et de créer un environnement isolé pour le développement et une maintenance facilitée.
2. La compilation de paquets directement sur la carte Jetson est un processus assez lent et, dans la plupart des cas, elle nécessite une connexion Internet pour télécharger les paquets dépendants. Ce problème peut être résolu en créant des images sur une machine hôte beaucoup plus puissante et en les flashant directement sur une carte SD qui sera ensuite utilisée sur la carte Jetson.
3. Pour améliorer les performances matérielles d'une carte Jetson, nous devons optimiser les applications logicielles afin qu'elles s'exécutent plus efficacement. Cela peut impliquer d'ajuster le code, d'utiliser des packages plus efficaces ou de réduire la charge sur la carte en évitant l'installation de fonctionnalités inutiles, telles que l'interface graphique Linux.

Installation de l'environnement ROS sur la carte Jetson en trois étapes

Dans cet article, je me concentrerai sur une configuration assez courante : la version ROS1 Melodic (Ubuntu 18.04) sur la carte NVIDIA Jetson Nano. Nous utiliserons Linux4Tegra, un système d'exploitation dédié à l'environnement ARM64 Jetson qui contient des scripts que nous pourrions réutiliser pour générer des fichiers IMG.

Étape 1. Créer les fichiers Docker ROS

Tout d'abord, nous devons préparer un environnement de compilation ARM64 sur notre machine hôte. Vous utiliserez probablement l'architecture standard AMD64 (par exemple, ubuntu 22.04) ; pour ce faire, vous devez installer l'outil QEMU. Le niveau principal où nous stockons notre configuration personnalisée sera un fichier docker (appelons-le Dockerfile.eg), dans lequel nous définissons la version du système L4T et installons les paquets ROS requis, par exemple :

# Installer les paquets de base
RUN apt-get update \
    && apt-get install -y \
    lsb-core \
    cmake \
    git \
    ninja-build \
    curl

RUN sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

RUN curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | apt-key add -

# Installer les paquets ROS - veuillez ajouter les suivants à la fin si nécessaire
RUN apt-get update \
    && apt-get install -y \
    ros-melodic-ros-base \
    ros-melodic-navigation \
    ros-melodic-robot-localization \
    ros-melodic-tf2-ros \
    ros-melodic-rviz \
    python-catkin-pkg \
    python-catkin-tools \
    python-rosdep \
    python-rosinstall \
    python-rosinstall-generator

Nous pouvons injecter et reconstruire nos dépôts afin d'obtenir un environnement entièrement plug-and-play. Dans le code ci-dessous, la 9e ligne est très utile pour éviter les erreurs liées aux dépendances de paquets requises et pour les préinstaller avant que la macro catkin_make ne démarre.

# Install and build your git repositories RUN mkdir -p /catkin_ws/src \ && cd /catkin_ws/src \ && git clone https://github.com/<myRepo>.git \ && git clone https://github.com/<myRepo1>.git \ && git clone https://github.com/<myRepo2>.git \ && cd /catkin_ws/ \ && . /opt/ros/melodic/setup.sh \ && rosdep install --from-paths src -y --ignore-src \ catkin_make_isolated --use-ninja --cmake-args -DCMAKE_BUILD_TYPE=Release

Nous pouvons ajouter des fichiers de ressources ou des répertoires à l'image docker si nécessaire. De plus, nous pouvons créer notre service système, par exemple roscoreinit.service, pour activer roscore à chaque démarrage du système L4T :

[Unit] Description=Init roscore After=remote-fs.target After=syslog.target [Service] ExecStart=/root/init_roscore.sh Restart=on-abort [Install] WantedBy=multi-user.target

Script dédié init_roscore.sh :

#!/bin/bash source /catkin_ws/devel_isolated/setup.bash roscore

Ajoutez l'activation de roscoreinit.service et init_roscore.sh dans le dockerfile :

COPY roscoreinit.service /lib/systemd/system/roscoreinit.service COPY init_roscore.sh /root/init_roscore.shRUN systemctl enable roscoreinit

Étape 2. Construire l'image

Pour construire docker et l'exporter vers un fichier, nous appelons les commandes ci-dessous :

docker build --build-arg --network=host . -f Dockerfile.eg -t myImage docker export "$(docker create --name nano-rootfs --platform linux/arm64 myImage)" -o myImage.tar

Ensuite, nous devons décompresser le système de fichiers racine (Rootfs) de l'étape précédente et, à l'aide du package de support de carte Linux4Tegra, nous créerons une image Jetson Nano qui peut être flashée directement sur la carte SD :

# BSP 32.7.2 plus de détails peuvent être trouvés ici : https://developer.nvidia.com/embedded/linux-tegra-r3272
L4T_PACKAGE=https://developer.nvidia.com/embedded/l4t/r32_release_v7.2/t210/jetson-210_linux_r32.7.2_aarch64.tbz2
L4T_PACKAGE_BUILD_DIR=l4t_bsp
wget --no-check-certificate -qO- $L4TPackage | tar -jxpf - -C $L4T_PACKAGE_BUILD_DIR
ROOTFS_L4T_DIR=/tmp/l4t/rootfs
mkdir -p $ROOTFS_L4T_DIR
tar --same-owner -xf myImage.tar -C $ROOTFS_L4T_DIR
# Ici, nous pourrions modifier le noyau Linux, étape facultative décrite dans la section suivante
# Générer le fichier IMG
ROOTFS_DIR=$ROOTFS_L4T_DIR $L4T_PACKAGE_BUILD_DIR/Linux_for_Tegra/tools/jetson-disk-image-creator.sh \
    -o myImage.img -b jetson-nano -r 300

Le fichier de sortie myImage.img est l'image finale qui peut être flashée directement sur la carte SD, par exemple, à l'aide de l'outillage balenaEtcher.

Étape 3, facultative. Recompiler le noyau Linux à partir des sources

Recompiler le noyau à partir des sources permet de sélectionner uniquement les fonctionnalités nécessaires. Cela peut se traduire par des performances système plus légères, plus rapides et plus stables. Il est parfois nécessaire de modifier considérablement la configuration du noyau Linux pour prendre en charge les périphériques demandés. À des fins de synchronisation des capteurs, nous pouvons activer diverses fonctionnalités telles que le Pulse per second (PPS) ou le Precision Time Protocol (PTP), afin que les nœuds ROS puissent fonctionner dans un environnement stable. Nous devons ensuite trouver une version de compilateur croisé GCC compatible et les sources du noyau. Dans notre scénario, nous consultons la page web NVIDIA ci-dessous qui décrit la version L4T 32.7.2 :

https://developer.nvidia.com/embedded/linux-tegra-r3272

Après avoir reconstruit le nouveau noyau, vous devez installer les device tree blobs dans le build du package L4T mentionné dans la section Build Image :

cp <build_from_sources_kernel>/arch/arm64/boot/Image $L4T_PACKAGE_BUILD_DIR/Linux_for_Tegra/kernel cp -r <build_from_sources_kernel>/arch/arm64/boot/dts/* $L4T_PACKAGE_BUILD_DIR/Linux_for_Tegra/kernel/dtb

Si votre NVIDIA Jetson Nano dispose d'une carte multimédia intégrée, vous devez également synchroniser le nouveau noyau avec l'eMMC lorsque le bootloader démarrera pour la première fois. Sur une carte Jetson Nano sans eMMC, le noyau sera initialisé à partir d'une carte SD externe ou d'un stockage USB sur lequel l'image L4T est installée directement.

Globalement, reconstruire le noyau Linux à partir des sources peut offrir une plus grande flexibilité et un meilleur contrôle du système, ce qui en fait une entreprise qui vaut la peine pour les développeurs avancés.

Résumé

Le développement et le déploiement de l'environnement ROS sur la carte NVIDIA Jetson permettent facilement d'empaqueter votre application et ses dépendances dans une image de conteneur.

Lors de la création d'une image Jetson, Docker fournit un environnement standardisé et reproductible qui garantit la cohérence entre les différentes versions. Cela est particulièrement important lorsqu'on travaille avec des systèmes embarqués comme le Jetson, où la compatibilité matérielle et l'optimisation sont critiques. Docker vous permet également de partager facilement votre image Jetson avec d'autres, réduisant le temps et les efforts nécessaires à la configuration et à l'installation. Il facilite également la mise en place d'un volet d'intégration continue.

En résumé, l'utilisation de Docker dans la création d'une image Jetson offre un environnement standardisé et reproductible qui garantit la cohérence entre les builds et simplifie le partage et la collaboration.

Vous recherchez des spécialistes en robotique ?

Découvrez comment nous pouvons accompagner votre prochain produit – consultez notreServices de robotique, et n'hésitez pas à nous contacter en cas de questions.

FAQ