Construire un char LEGO autonome low-cost avec NVIDIA Jetson Nano & Isaac SDK

Construire un char LEGO autonome low-cost avec NVIDIA Jetson Nano & Isaac SDK

Dans ce guide, je démontre comment transformer un kit LEGO EV3 standard en robot à chenilles fully autonome, propulsé par un NVIDIA Jetson Nano, le Isaac SDK, un LiDAR YDLIDAR-X4, et une caméra vision Pixy2. Le résultat est une alternative budget-friendly aux designs de référence Carter et Kaya, tout en conservant toutes les capacités avancées de perception et planification de la stack robotique NVIDIA.

Allez à la Partie 8 ou Partie 10 pour une démo complète de navigation autonome.

Le projet comprend les composants suivants :

• NVIDIA Jetson Nano dev board – exécute le moteur robotique Isaac
• Brique EV3 – contrôle les moteurs (incluse dans le Kit Robot EV3 31313)
• Base à chenilles – construite depuis pièces LEGO Technic et deux gros moteurs (tout fourni dans le Kit Robot EV3 31313)
• YDLIDAR X4 LiDAR
• Pixy2 caméra pour la vision

Pourquoi Isaac SDK et pas ROS ?

• Il existe de nombreux tutos ROS, mais seulement une poignée de guides officiels Isaac SDK.
• Isaac SDK est purpose-built pour hardware Jetson, donnant la meilleure performance sur le Nano.
• Tous les algorithmes core — de la perception à la planification — sont GPU-accélérés, rendant le Nano bien plus capable qu'un Raspberry Pi 4.
• Le rendeur Unity 3D d'IsaacSim offre une simulation photoréaliste qui facilite le reality gap.

Pourquoi pièces LEGO ?

• Stock important de pièces disponible.
• Servos haute qualité et construction robuste.
• Pas de soudure requise ; le système est fully modulaire.
• Boîtier optionnel imprimé 3D pour Jetson Nano (voir repo PELA-blocks).

Choisir cette voie introduit quelques défis :

• Le hardware LEGO n'est pas nativement supporté par Isaac SDK ; seules les références Carter et Kaya existent.
• Isaac SDK supporte un ensemble limité de composants hardware.
• La cross-compilation est requise pour cibles x86-64, arm64, et armv5tejl.
• Certains composants restent closed source.

Partie 1 : Démarrage

1. Installer Isaac SDK

• Suivez le guide d'installation officiel.
• Exécutez les applications exemples pour vérifier l'environnement.
• Utilisez la version SDK 2019.3 pour compatibilité maximale.

2. Reconnaissance vocale (optionnel)

• Installez CUDA 10.0, cuDNN 7.6.3, et TensorRT 6.0.
• Installez TensorFlow 1.15.0 avec support GPU.

3. Image EV3dev

Flashez la dernière image ev3dev-stretch sur une carte microSD ou microSDHC. microSDXC n'est pas supporté par la brique EV3.

4. Cross-compilateur ARM pour ev3dev

sudo apt-get install gcc-arm-linux-gnueabi g++-arm-linux-gnueabi 

Comme Ubuntu 18.04 (hôte et Jetson) utilise GLIBC 2.28 tandis qu'ev3dev utilise GLIBC 2.24, nous devons compiler avec liaison dynamique sauf pour la librairie math. Ajustez le fichier jetson-ev3/toolchain/CROSSTOOL en conséquence, ou utilisez une image Docker Debian 9.

5. Espace de travail Jetson + EV3

git clone https://github.com/andrei-ace/jetson-ev3.git 

Éditez jetson-ev3/WORKSPACE pour pointer vers votre chemin Isaac SDK :

local_repository( name = 'com_nvidia_isaac', path = '/home/andrei/ml/isaac' ) 

Et mettez à jour le chemin du toolchain dans jetson-ev3/toolchain/CROSSTOOL :

# edit with your path to the toolchain linker_flag: '-L/home/andrei/ml/jetson-ev3/toolchain' 

6. Connecter Jetson Nano avec EV3

Utilisez un câble USB-A vers mini-USB. SSH dans l'EV3 depuis le Jetson :

ssh user@ev3dev.local 

Mot de passe par défaut : maker.

7. Tutoriel Ping-Pong

Le Codelet « Ping-Pong » d'Isaac démontre la communication inter-processus. Adaptez-le pour envoyer messages entre le Jetson et la brique EV3.

Construisez le serveur EV3 :

bazel build --config=ev3dev //apps/ev3/ping_pong:ev3_pong 

Déployez le client sur le Jetson :

<YOUR-ISAAC-INSTALL>/engine/build/deploy.sh --remote_user <YOUR-USER-JETSON> -p //apps/ev3/ping_pong:ping_pong-pkg -d jetpack43 -h <YOUR-JETSON-IP> 

Exécutez les deux binaires. L'EV3 devrait dire les messages « Ping ».

Partie 2 : Contrôler un moteur depuis Isaac

En utilisant les mêmes principes, contrôlez les moteurs EV3 via un driver Isaac personnalisé qui imite la base Segway RMP. Le Ev3ControlServer tourne sur l'EV3 :

bazel build --config=ev3dev //packages/ev3/ev3dev:ev3_control_server ev3_control_server ev3dev.local:9000 

Intégrez le serveur avec le Sight joystick virtuel pour téléopération manuelle.

Partie 3 : Construire le robot

Le châssis suit de près le design officiel EV3 Track3r de LEGO. Le boîtier Jetson Nano provient du repo GitHub.

Partie 4 : Architecture apps Isaac

Une app Isaac comprend trois couches :

• Graph – nœuds : définit les composants.
• Graph – arêtes : définit le flux de données.
• Configuration : paramétrise les nœuds.

Voici un exemple concis d'app navigation contrôlée par la voix. (Voir le dossier complet voice_control pour tous fichiers JSON.)

{ 'name': 'voice_control', 'modules': [ '//apps/ev3/voice_control:voice_control_goal_generator', '@com_nvidia_isaac//packages/navigation', '@com_nvidia_isaac//packages/planner' ], 'config_files': [ 'apps/ev3/voice_control/model/isaac_vcd_model.metadata.json' ], 'config': { ... }, 'graph': { 'nodes': [...], 'edges': [...] } } 

Les sous-graphes sont réutilisables ; la stack navigation est partagée across all robot variants.

Partie 5 : Exécuter apps Isaac sur EV3

Le driver EV3 implémente la même API que la base Segway RMP, permettant la réutilisation directe d'apps Isaac existantes comme le contrôleur joystick, GMapping distribué, et stack navigation complète.

Partie 6 : Calibration odométrie

Une odométrie précise est critique pour l'opération autonome. Le Ev3ControlServer expose deux appels RPC :

• command(Control) – envoie vitesses linéaire et angulaire.
• state() – retourne les vitesses linéaire et angulaire courantes.

En utilisant le rayon de roue et la largeur de voie, calculez la vitesse linéaire comme :

if left == right: v = left elif left == -right: v = 0 else: v = (left + right) / 2 

La vitesse angulaire dérive du différentiel des vitesses de roue divisé par la largeur de voie.

Partie 7 : Navigation autonome contrôlée par la voix

Le sous-graphe détection vocale écoute un micro et émet un voice_command_id quand un des mots-clés entraînés est détecté. J'ai entraîné un RNN sur trois mots — « jetson », « left », et « right » — en utilisant le Isaac Speech Toolkit. Le modèle résultant peut être téléchargé depuis le dépôt du projet.

Quand une commande est reçue, le GoalGenerator publie un but au planificateur global. Par exemple, pour faire pivoter le robot 90° à gauche :

auto proto = rx_detected_command().getProto(); int id = proto.getCommandId(); auto goal_proto = tx_goal().initProto(); goal_proto.setStopRobot(true); goal_proto.setTolerance(0.1); goal_proto.setGoalFrame('robot'); ToProto(Pose2d::Rotation(90), goal_proto.initGoal()); tx_goal().publish(); 

En pratique, le système fonctionne fiablement en mode 10 W. À 5 W, la latence d'inférence (≈30 ms) est trop élevée pour un fonctionnement fluide.

Partie 8 : Mapping avec GMapping distribué

Le mapping est effectué sur un PC hôte tandis que l'EV3 fournit les données LiDAR. Déployez l'app GMapping distribué sur le Jetson :

./engine/build/deploy.sh --remote_user andrei -p //apps/ev3:gmapping_distributed_ev3-pkg -d jetpack43 -h 192.168.0.218 

Sur l'hôte, lancez :

bazel run apps/ev3:gmapping_distributed_host 

Assurez-vous que le fichier JSON hôte pointe vers la bonne IP Jetson :

'tcp_subscriber': { 'isaac.alice.TcpSubscriber': { 'port': 5000, 'host': '192.168.0.218' } } 

Après quelques minutes d'exploration, une grille d'occupation haute résolution est générée.

Conclusion

Avec un investissement modéré en pièces LEGO Technic, un YDLIDAR, et une caméra Pixy2, vous pouvez construire un robot à chenilles fully autonome qui exploite toute la puissance du SDK Isaac de NVIDIA. Le système supporte commandes vocales, mapping LiDAR, et perception GPU-accélérée, en faisant une plateforme polyvalente pour recherche, éducation, et projets hobby.

Tout le code, fichiers de configuration, et modèles entraînés sont disponibles dans le dépôt du projet.