-p-500.png)
Un Cerveau, n'importe quel Robot.
Note : La version anglaise est la documentation officielle et la plus à jour. Cette traduction peut ne pas refléter les dernières modifications.
Le BotBrain Workspace est un framework ROS2 modulaire et open source pour le contrôle autonome de robots, la navigation et la localisation. Conçu avec une architecture agnostique aux robots, il permet le développement et le déploiement rapides d'applications robotiques avancées sur plusieurs plateformes de robots.
Caractéristiques Principales :
- 🤖 Support Multi-Robot : Base de code unique pour Go2, Tita, G1 et robots personnalisés
- 🗺️ SLAM Visuel : Localisation basée sur RTABMap avec support double caméra
- 🎮 Modes de Contrôle Multiples : Joystick, interface web et navigation autonome
- 👁️ Vision IA : Détection d'objets YOLOv8/v11
- 🐳 Prêt pour Docker : Déploiement conteneurisé avec accélération GPU
- 🔄 Gestion du Cycle de Vie : Orchestration robuste des nœuds et récupération des pannes
- Prérequis Matériels
- Démarrage Rapide
- Structure du Dépôt
- Création d'un Package Robot Personnalisé
- Vue d'Ensemble des Packages
- Services Docker
- Configuration
- Unitree Go2
- Unitree G1
- Tita
- Robots Personnalisés - Suivez le Guide de Package Robot Personnalisé
- Plateforme Robot : Un des robots supportés ci-dessus
- Ordinateur Embarqué :
- Nvidia Jetson Orin Series ou plus récent
- Capteurs :
- Caméras Intel RealSense (pour SLAM visuel)
- LiDAR (pour SLAM basé sur LiDAR)
- Réseau :
- Connexion Ethernet au robot
- Adaptateur Wi-Fi (pour contrôle à distance)
- Manette de Jeu : Pour la téléopération
Pour le déploiement conteneurisé :
# Démarrer tous les services
docker compose up -d
# Démarrer des services spécifiques
docker compose up -d state_machine bringup localization navigation
# Voir les logs
docker compose logs -f bringup
# Arrêter les services
docker compose down# Vérifier les nœuds actifs
ros2 node list
# Vérifier les topics
ros2 topic listSi vous voulez utiliser la même image docker pour le développement, sans créer un nouveau service, il est possible d'exécuter un conteneur de développement interactif :
# Initialiser le conteneur de développement
cd botbrain_ws
docker compose up dev -d
# Initialiser un terminal interactif
docker compose exec dev bashUne fois le terminal interactif ouvert, vous pouvez l'utiliser pour créer, compiler et exécuter de nouvelles fonctionnalités qui ne sont pas encore intégrées aux services docker.
botbrain_ws/
├── README.md # Ce fichier
├── LICENSE # Licence MIT
│
├── robot_config.yaml # Fichier de configuration principal
├── install.sh # Script d'installation automatisée
├── robot_select.sh # Aide à la sélection du robot
│
├── docker-compose.yaml # Définition des services Docker
├── botbrain.service # Service systemd de démarrage automatique
├── cyclonedds_config.xml # Configuration du middleware DDS
│
└── src/ # Packages ROS 2
│
├── Packages Système Central
│ ├── bot_bringup/ # Lancement principal & coordination twist mux
│ ├── bot_custom_interfaces/ # Messages, services, actions personnalisés
│ └── bot_state_machine/ # Gestion du cycle de vie & états
│
├── Modèle Robot & Visualisation
│ └── bot_description/ # Modèles URDF/XACRO & robot_state_publisher
│
├── Navigation & Localisation
│ ├── bot_localization/ # SLAM RTABMap (visuel & LiDAR)
│ └── bot_navigation/ # Stack de navigation Nav2
│
├── Perception & Contrôle
│ ├── bot_yolo/ # Détection d'objets YOLOv8/v11
│ └── joystick-bot/ # Interface manette de jeu
│
├── IA & Surveillance
│ ├── bot_jetson_stats/ # Surveillance matérielle Jetson
│ └── bot_rosa/ # Contrôle par langage naturel ROSA AI
│
└── Packages Spécifiques aux Robots
├── g1_pkg/ # Interface matérielle Unitree G1
├── go2_pkg/ # Interface matérielle Unitree Go2
├── tita_pkg/ # Interface matérielle Tita
└── your_robot_pkg/ # Votre robot personnalisé (voir guide ci-dessous)
Pour ajouter le support d'une nouvelle plateforme robot, suivez ce guide en utilisant go2_pkg comme modèle de référence.
Note : Le package go2_pkg communique avec le robot Unitree Go2 via des topics ROS 2 (s'abonnant aux topics ROS 2 natifs d'Unitree et les republiant au format BotBrain). Votre package robot personnalisé peut utiliser une communication similaire basée sur les topics, des APIs matérielles directes ou des interfaces SDK selon l'architecture de votre robot. L'idée est de créer une interface de package standard entre les packages botbrain_ws et le robot.
Votre package robot personnalisé doit suivre cette convention de nommage pour fonctionner parfaitement avec tous les packages : {robot_model}_pkg
{robot_model}_pkg/
├── package.xml # Manifeste du package ROS 2
├── CMakeLists.txt # Configuration de build
├── README.md # Documentation du package
├── launch/
│ └── robot_interface.launch.py # REQUIS : Lanceur principal de l'interface matérielle
├── config/
│ └── nav2_params.yaml # REQUIS : Paramètres de navigation
├── scripts/
│ ├── {robot_model}_read.py # REQUIS : Lit les données des capteurs du robot
│ └── {robot_model}_write.py # REQUIS : Envoie les commandes au robot
├── {robot_model}_pkg/ # Répertoire du package Python
│ └── tools/ # OPTIONNEL : Outils de l'assistant ROSA AI
│ ├── __init__.py # Initialisation vide du package
│ └── {robot_model}.py # Outils LangChain pour l'intégration ROSA
├── xacro/
│ └── robot.xacro # REQUIS : Modèle URDF du robot
└── meshes/
└── *.dae, *.stl # Maillages visuels & de collision
Créez la structure du package en utilisant les outils ROS 2 (si vous n'avez pas ros2 installé sur votre système hôte, cela peut être fait depuis un conteneur de développement) :
cd src/
ros2 pkg create {robot_model}_pkg --build-type ament_cmake --dependencies rclcpp rclpy
cd {robot_model}_pkgCréez les répertoires requis :
mkdir -p launch config scripts xacro meshes mapsÉditez package.xml et ajoutez les dépendances requises :
- Ajoutez
bot_custom_interfacescomme dépendance - Mettez à jour le nom du package, la version, la description et les informations du mainteneur
- Assurez-vous que toutes les dépendances de messages de capteurs sont incluses
Mettez à jour la configuration de build pour installer toutes les ressources du package :
- Installez le répertoire des fichiers launch
- Installez le répertoire des fichiers config
- Installez les scripts comme exécutables
- Installez les répertoires xacro, urdf et meshes
- Utilisez
ament_python_install_package()pour les modules Python
CRITIQUE : Créez launch/robot_interface.launch.py (nom exact requis)
Ce fichier launch doit :
- Lire
robot_config.yamldepuis la racine du workspace - Extraire
robot_namepour la configuration du namespace - Lancer des nœuds de cycle de vie pour la lecture et l'écriture matérielle
- Utiliser
LifecycleNodedelaunch_ros.actions - Appliquer le namespace correct à tous les nœuds
Référence : Voir go2_pkg/launch/robot_interface.launch.py pour un exemple complet.
Créez scripts/{robot_model}_read.py - Lit les données des capteurs et publie sur ROS 2 :
Ce nœud de cycle de vie doit :
- S'initialiser comme
LifecycleNodeavec le nomrobot_read_node - Implémenter les callbacks de cycle de vie :
on_configure,on_activate,on_deactivate,on_cleanup - Dans
on_configure: Créer des publishers pour l'odométrie, l'IMU, les états des articulations et la batterie - Dans
on_activate: Démarrer la boucle de lecture des données (typiquement 50Hz) depuis le matériel/topics du robot - Traiter les données des capteurs du robot et publier sur les topics ROS 2
- Dans
on_deactivate: Arrêter la publication des données mais maintenir les connexions - Dans
on_cleanup: Fermer les connexions matérielles et libérer les ressources
Référence : Voir go2_pkg/scripts/go2_read.py pour l'implémentation complète.
Créez scripts/{robot_model}_write.py - Reçoit les commandes et les envoie au robot :
Ce nœud de cycle de vie doit :
- S'initialiser comme
LifecycleNodeavec le nomrobot_write_node - Dans
on_configure: Créer un subscriber pour le topiccmd_vel_outet établir la communication avec le robot - Implémenter un callback pour recevoir les commandes de vitesse et les transmettre au matériel du robot
- Dans
on_deactivate: Envoyer une commande d'arrêt (vitesse nulle) au robot - Dans
on_cleanup: Fermer les connexions matérielles et libérer les ressources - Optionnellement : Implémenter des services spécifiques au robot (changement de mode, contrôle de démarche, etc.)
Référence : Voir go2_pkg/scripts/go2_write.py pour l'implémentation complète.
Créez config/nav2_params.yaml avec les spécifications de votre robot. Voir la Documentation Nav2 comme référence.
Vous devrez ajouter un caractère joker aux sections de configuration des nœuds. Voir go2_pkg/config/nav2_params.yaml pour un exemple de configuration complète.
Créez xacro/robot.xacro avec le modèle URDF de votre robot :
Votre fichier XACRO doit définir :
base_linkcomme le lien principal du corps du robotinterface_linkcomme la partie d'interface entre le robot et BotBrain- Toutes les articulations et liens du robot (jambes, bras, etc.)
- Les liens des capteurs (caméras, LiDAR, IMU)
- Les maillages visuels pour la visualisation RViz
- Les maillages de collision pour la navigation
- Les limites des articulations et la dynamique
- Les propriétés inertielles
Référence : Voir go2_pkg/xacro/robot.xacro pour la description complète du robot.
Mettez à jour le robot_config.yaml du workspace (cela peut être fait via install.sh) :
robot_configuration:
robot_name: "mon_robot" # Namespace pour tous les topics
robot_model: "votre_robot" # Doit correspondre au nom du package sans "_pkg"
description_file_type: "xacro" # "xacro" ou "urdf"
network_interface: "eth0" # Interface réseau pour la communication robotIMPORTANT : Le champ robot_model doit correspondre au nom de votre package sans le suffixe _pkg :
- Nom du package :
votre_robot_pkg - robot_model :
votre_robot
# Compilez votre package
cd ~/botbrain_workspace/BotBrain/botbrain_ws
colcon build --packages-select votre_robot_pkg
# Sourcez le workspace
source install/setup.bash
# Testez votre interface matérielle
ros2 launch votre_robot_pkg robot_interface.launch.py
# Lancez avec le système complet
ros2 launch bot_bringup bringup.launch.pyVous pouvez compiler et tester le nouveau package en utilisant un conteneur de développement.
ROSA (Robot Operating System Assistant) est un assistant IA qui permet le contrôle en langage naturel de votre robot. En créant des outils pour ROSA, les utilisateurs peuvent interagir avec votre robot en utilisant des commandes conversationnelles.
Créez la structure du répertoire des outils :
mkdir -p {robot_model}_pkg/tools
touch {robot_model}_pkg/tools/__init__.py
touch {robot_model}_pkg/tools/{robot_model}.pyLe système BotBrain trouvera et utilisera automatiquement votre package basé sur ces conventions :
- Nommage du Package : format
{robot_model}_pkg - Fichier Launch :
launch/robot_interface.launch.py(nom exact requis) - Config Navigation :
config/nav2_params.yaml(utilisé par bot_navigation) - Fichiers de Description :
xacro/robot.xacroouurdf/robot.urdf(utilisé par bot_description)
Pour une intégration système complète, votre interface matérielle doit publier :
| Topic | Type de Message | Description | Fréquence |
|---|---|---|---|
/{namespace}/odom |
nav_msgs/Odometry | Odométrie du robot | 50Hz |
/{namespace}/imu |
sensor_msgs/Imu | Données IMU | 100Hz |
/{namespace}/joint_states |
sensor_msgs/JointState | Positions/vitesses des articulations | 50Hz |
Et s'abonner à :
| Topic | Type de Message | Description |
|---|---|---|
/{namespace}/cmd_vel_out |
geometry_msgs/Twist | Commandes de vitesse depuis twist_mux |
| Package | Description | Documentation |
|---|---|---|
| bot_bringup | Coordination principale du lancement, multiplexeur twist et orchestration système | README |
| bot_state_machine | Gestion du cycle de vie, coordination des nœuds et contrôle de l'état du système | README |
| bot_custom_interfaces | Messages, services et actions ROS 2 personnalisés | README |
| bot_description | Modèles URDF/XACRO du robot et robot_state_publisher | README |
| Package | Description | Documentation |
|---|---|---|
| bot_localization | SLAM RTABMap avec support pour le mapping visuel et basé sur LiDAR | README |
| bot_navigation | Stack de navigation Nav2 avec configuration agnostique au robot | README |
| Package | Description | Documentation |
|---|---|---|
| bot_yolo | Détection d'objets YOLOv8/v11 avec accélération TensorRT | README |
| joystick-bot | Interface manette de jeu avec interrupteur de sécurité dead-man | README |
| Package | Description | Documentation |
|---|---|---|
| go2_pkg | Interface matérielle et description du Unitree Go2 quadrupède | README |
| tita_pkg | Interface matérielle et description du Tita quadrupède | README |
Le workspace inclut plusieurs services Docker pour le déploiement conteneurisé :
| Service | Description | Démarrage Auto | Dépendances |
|---|---|---|---|
dev |
Conteneur de développement (interactif) | Non | - |
builder_base |
Compile tous les packages du workspace | Non | - |
state_machine |
Service de gestion du cycle de vie | Oui | - |
bringup |
Bringup principal du robot | Oui | state_machine |
localization |
Localisation RTABMap | Oui | bringup |
navigation |
Serveurs de navigation Nav2 | Oui | localization |
rosa |
Services d'appel d'outils IA | Oui | bringup |
yolo |
Service de détection d'objets | Oui | bringup |
# Démarrer tous les services
docker compose up -d
# Démarrer un service spécifique avec ses dépendances
docker compose up -d navigation # Démarre automatiquement bringup, localization
# Voir les logs
docker compose logs -f bringup
# Arrêter tous les services
docker compose down
# Recompiler après des modifications de code
docker compose build
docker compose up -dLe fichier robot_config.yaml est le point central de configuration :
robot_configuration:
# Identifiant du robot - utilisé comme namespace pour tous les topics
robot_name: "" # Exemple : "go2_robot1", "tita_lab"
# Type de robot - détermine quel package matériel lancer
robot_model: "go2" # Options : "go2", "tita", "votre_robot"
# Format du fichier de description
description_file_type: "xacro" # Options : "xacro", "urdf"
# Interface réseau pour la communication ROS2
network_interface: "eno1" # Exemple : "eth0", "wlan0", "eno1"
# Spécifique à Tita : namespace pour la communication du robot Tita
tita_namespace: "tita3036731" # Utilisé uniquement quand robot_model: "tita"
# Clé API OpenAI pour les fonctionnalités IA (optionnel)
openai_api_key: "" # Requis pour l'assistant ROSA AI
# Configuration Wi-Fi (optionnel)
wifi_interface: "" # Nom de l'interface Wi-Fi (ex. : "wlan0")
wifi_ssid: "" # SSID du réseau Wi-Fi
wifi_password: "" # Mot de passe du réseau Wi-FiLe workspace utilise CycloneDDS pour la communication ROS 2. Configuration dans cyclonedds_config.xml :
Définissez l'interface réseau dans robot_config.yaml pour correspondre à votre connexion matérielle.
Le fichier botbrain.service active le démarrage automatique au boot :
# Installer le service (fait par install.sh)
sudo cp botbrain.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable botbrain.service
# Contrôle manuel
sudo systemctl start botbrain.service # Démarrer maintenant
sudo systemctl stop botbrain.service # Arrêter
sudo systemctl status botbrain.service # Vérifier le statut
# Voir les logs
journalctl -u botbrain.service -fVoir le guide Création d'un Package Robot Personnalisé ci-dessus. Nous accueillons particulièrement les contributions qui ajoutent le support pour de nouvelles plateformes de robots !
Fait avec ❤️ au Brésil
.png)