Comment configurer Foxglove : Un guide pratique

En bref

• Installez Foxglove en 2 minutes via le bureau, le web ou Docker.
• Connectez-vous à ROS 2 avec ros2 topic list et le pont ROS de Foxglove.
• Visualisez les logs MCAP plus rapidement que les fichiers ROS Bag (utilisez mcap record).
• Construisez des tableaux de bord avec des panneaux glissables-déposables pour la 3D, les images et les graphiques.
• Déboguez les données en direct et enregistrées avec des contrôles de synchronisation temporelle.
• Étendez Foxglove avec des panneaux personnalisés en TypeScript pour des schémas propriétaires.

1. Installation de Foxglove et connexion à ROS 2

Installer Foxglove

Choisissez votre méthode :

Bureau (Recommandé pour ROS 2)

# macOS (Homebrew)
brew install --cask foxglove-studio

# Linux (AppImage)
wget https://github.com/foxglove/studio/releases/download/v2.12.0/FoxgloveStudio-2.12.0.AppImage
chmod +x FoxgloveStudio-*.AppImage
./FoxgloveStudio-*.AppImage

# Windows (Winget)
winget install Foxglove.FoxgloveStudio

Application Web (Sans installation)

Ouvrez https://app.foxglove.dev dans Chrome ou Firefox.

Docker (Pour CI/CD)

docker run -p 8080:8080 foxglove/studio

Connexion à ROS 2

1. Vérifiez que ROS 2 est en cours d'exécution :

   ros2 topic list
   

   Copy

   Exemple de sortie :

   /cmd_vel
   /scan
   /tf
   /odom
   

   Copy

2. Lancez Foxglove et connectez-vous :

   • Ouvrez Foxglove → Cliquez sur "Se connecter" → Sélectionnez "ROS 2".
   • Entrez votre identifiant de domaine ROS 2 (par défaut : 0) :

     ros2 run foxglove_bridge foxglove_bridge --ros-domain-id 0
     

     Copy
   • Dans Foxglove, sélectionnez le même identifiant de domaine.

3. Résultat attendu :

   • Foxglove affichera tous les sujets ROS 2. Cliquez sur "S'abonner" pour démarrer le flux.

2. Le format de journal MCAP

Pourquoi MCAP ?

Le format MCAP (Micro-Format pour les données ROS) est plus rapide et plus compact que les fichiers ROS Bag Source : Spécification MCAP. Utilisez-le pour :

• De grands jeux de données de robots.
• Le stockage cloud (par exemple, Foxglove Data Platform).

Enregistrer des données MCAP

# Installer les outils MCAP
pip install rosbags-mcap

# Enregistrer depuis les sujets ROS 2
ros2 bag record -a --storage mcap -o données_robot.mcap

Lecture dans Foxglove

1. Ouvrez Foxglove → Glissez-déposez données_robot.mcap dans l'application.
2. Utilisez la barre de défilement temporelle pour parcourir les données.

3. Création de mises en page de visualisation

Créer un tableau de bord

1. Ajouter des panneaux :

   • Glissez-déposez "Panneau 3D", "Panneau Image" ou "Panneau de Graphique" depuis la barre latérale.
   • Exemple : Visualisez /scan (LiDAR) en 3D et /image_raw sous forme d'image.

2. Enregistrer la mise en page :

   # Exporter en JSON
   foxglove studio export-layout --output mon_tableau_de_bord.json
   

   Copy

   Exemple de mon_tableau_de_bord.json :

   {
     "panels": [
       {
         "type": "3D",
         "topic": "/scan",
         "frame": "base_link"
       },
       {
         "type": "Image",
         "topic": "/image_raw"
       }
     ]
   }
   

   Copy

3. Charger la mise en page :

   • Ouvrez Foxglove → "Charger la mise en page" → Sélectionnez mon_tableau_de_bord.json.

4. Panneaux 3D, Image et Graphique

Panneau 3D (LiDAR/URDF)

• Ajoutez un panneau 3D → Sélectionnez le sujet /scan.
• Configurer :
  • Définissez frame sur base_link (à partir de /tf).
  • Activez "Afficher les cadres TF" pour visualiser la pose du robot.

Panneau Image (Caméra)

• Ajoutez un panneau Image → Sélectionnez /image_raw.
• Ajustez :
  • Définissez encoding sur bgr8 (courant pour les caméras ROS 2).

Panneau Graphique (Séries temporelles)

• Ajoutez un panneau Graphique → Sélectionnez /odom/pose/pose/position/x.
• Personnalisez :
  • Ajoutez une deuxième série : /twist/twist/linear/x.
  • Utilisez "Échelle automatique" pour des plages dynamiques.

5. Débogage en direct et lecture enregistrée

Débogage en direct

1. Diffusez les données ROS 2 en temps réel :

   ros2 run foxglove_bridge foxglove_bridge --ros-domain-id 0
   

   Copy
2. Pause/Reprise du flux avec les contrôles temporels.

Lecture enregistrée

1. Chargez un fichier MCAP :

   foxglove studio open données_robot.mcap
   

   Copy
2. Synchronisation temporelle :
   • Utilisez "Synchronisation temporelle" pour aligner plusieurs logs.

6. Extensions personnalisées et schémas de messages

Ajouter un panneau personnalisé

1. Créez une extension TypeScript :

   npx @foxglove/create-extension mon-panneau-personnalisé
   cd mon-panneau-personnalisé
   

   Copy
2. Modifiez src/panel.ts :

   import { Panel } from '@foxglove/studio';
   
   export class MonPanneauPersonnalisé extends Panel {
     render() {
       return <div>Visualisation personnalisée pour mon_sujet</div>;
     }
   }
   

   Copy
3. Compilez et chargez :

   npm run build
   foxglove studio load-extension ./dist
   

   Copy

Définir des schémas de messages personnalisés

1. Ajoutez un schéma dans foxglove.config.json :

   {
     "schemas": {
       "mon_espace_nominal/MonMessage": {
         "fields": [
           {"name": "x", "type": "float32"},
           {"name": "y", "type": "float32"}
         ]
       }
     }
   }
   

   Copy
2. Utilisez dans Foxglove :
   • Sélectionnez le sujet → Foxglove analysera le schéma personnalisé.

7. Flux de travail d'équipe pour le débogage de flotte

Partager une session en direct

1. Hébergez une session :

   foxglove studio share --port 8080
   

   Copy
2. Invitez vos collègues à https://app.foxglove.dev avec le lien.

Stockage cloud (Foxglove Data Platform)

1. Téléversez les données :

   foxglove data upload données_robot.mcap
   

   Copy
2. Accédez dans Foxglove :
   • Connectez-vous → Sélectionnez "Cloud" → Chargez l'ensemble de données.

Que faire ensuite ?

1. Enregistrez et analysez une mission complète de robot avec mcap record.
2. Construisez un tableau de bord personnalisé pour les indicateurs clés de votre robot.
3. Étendez Foxglove avec un panneau TypeScript pour les sujets propriétaires.

Pour une infrastructure d'IA physique et son déploiement, explorez les outils de Hyperion pour les systèmes VLA incarnés et les runtime edge. Contactez-nous pour discuter de votre projet.